text: //===------- CGObjCGNU.cpp - Emit LLVM Code from ASTs for a Module --------===//
  //
  // 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 GNU runtime.  The
  // class in this file generates structures used by the GNU Objective-C runtime
  // library.  These structures are defined in objc/objc.h and objc/objc-api.h in
  // the GNU runtime distribution.
  //
  //===----------------------------------------------------------------------===//
  
  #include "CGObjCRuntime.h"
  #include "CGCleanup.h"
  #include "CodeGenFunction.h"
  #include "CodeGenModule.h"
  #include "CGCXXABI.h"
  #include "clang/CodeGen/ConstantInitBuilder.h"
  #include "clang/AST/ASTContext.h"
  #include "clang/AST/Decl.h"
  #include "clang/AST/DeclObjC.h"
  #include "clang/AST/RecordLayout.h"
  #include "clang/AST/StmtObjC.h"
  #include "clang/Basic/FileManager.h"
  #include "clang/Basic/SourceManager.h"
  #include "llvm/ADT/SmallVector.h"
  #include "llvm/ADT/StringMap.h"
  #include "llvm/IR/DataLayout.h"
  #include "llvm/IR/Intrinsics.h"
  #include "llvm/IR/LLVMContext.h"
  #include "llvm/IR/Module.h"
  #include "llvm/Support/Compiler.h"
  #include "llvm/Support/ConvertUTF.h"
  #include <cctype>
  
  using namespace clang;
  using namespace CodeGen;
  
  namespace {
  
  std::string SymbolNameForMethod( StringRef ClassName,
       StringRef CategoryName, const Selector MethodName,
      bool isClassMethod) {
    std::string MethodNameColonStripped = MethodName.getAsString();
    std::replace(MethodNameColonStripped.begin(), MethodNameColonStripped.end(),
        ':', '_');
    return (Twine(isClassMethod ? "_c_" : "_i_") + ClassName + "_" +
      CategoryName + "_" + MethodNameColonStripped).str();
  }
  
  /// Class that lazily initialises the runtime function.  Avoids inserting the
  /// types and the function declaration into a module if they're not used, and
  /// avoids constructing the type more than once if it's used more than once.
  class LazyRuntimeFunction {
    CodeGenModule *CGM;
    llvm::FunctionType *FTy;
    const char *FunctionName;
    llvm::FunctionCallee Function;
  
  public:
    /// Constructor leaves this class uninitialized, because it is intended to
    /// be used as a field in another class and not all of the types that are
    /// used as arguments will necessarily be available at construction time.
    LazyRuntimeFunction()
        : CGM(nullptr), FunctionName(nullptr), Function(nullptr) {}
  
    /// Initialises the lazy function with the name, return type, and the types
    /// of the arguments.
    template <typename... Tys>
    void init(CodeGenModule *Mod, const char *name, llvm::Type *RetTy,
              Tys *... Types) {
      CGM = Mod;
      FunctionName = name;
      Function = nullptr;
      if(sizeof...(Tys)) {
        SmallVector<llvm::Type *, 8> ArgTys({Types...});
        FTy = llvm::FunctionType::get(RetTy, ArgTys, false);
      }
      else {
        FTy = llvm::FunctionType::get(RetTy, None, false);
      }
    }
  
    llvm::FunctionType *getType() { return FTy; }
  
    /// Overloaded cast operator, allows the class to be implicitly cast to an
    /// LLVM constant.
    operator llvm::FunctionCallee() {
      if (!Function) {
        if (!FunctionName)
          return nullptr;
        Function = CGM->CreateRuntimeFunction(FTy, FunctionName);
      }
      return Function;
    }
  };
  
  
  /// GNU Objective-C runtime code generation.  This class implements the parts of
  /// Objective-C support that are specific to the GNU family of runtimes (GCC,
  /// GNUstep and ObjFW).
  class CGObjCGNU : public CGObjCRuntime {
  protected:
    /// The LLVM module into which output is inserted
    llvm::Module &TheModule;
    /// strut objc_super.  Used for sending messages to super.  This structure
    /// contains the receiver (object) and the expected class.
    llvm::StructType *ObjCSuperTy;
    /// struct objc_super*.  The type of the argument to the superclass message
    /// lookup functions.
    llvm::PointerType *PtrToObjCSuperTy;
    /// LLVM type for selectors.  Opaque pointer (i8*) unless a header declaring
    /// SEL is included in a header somewhere, in which case it will be whatever
    /// type is declared in that header, most likely {i8*, i8*}.
    llvm::PointerType *SelectorTy;
    /// LLVM i8 type.  Cached here to avoid repeatedly getting it in all of the
    /// places where it's used
    llvm::IntegerType *Int8Ty;
    /// Pointer to i8 - LLVM type of char*, for all of the places where the
    /// runtime needs to deal with C strings.
    llvm::PointerType *PtrToInt8Ty;
    /// struct objc_protocol type
    llvm::StructType *ProtocolTy;
    /// Protocol * type.
    llvm::PointerType *ProtocolPtrTy;
    /// Instance Method Pointer type.  This is a pointer to a function that takes,
    /// at a minimum, an object and a selector, and is the generic type for
    /// Objective-C methods.  Due to differences between variadic / non-variadic
    /// calling conventions, it must always be cast to the correct type before
    /// actually being used.
    llvm::PointerType *IMPTy;
    /// Type of an untyped Objective-C object.  Clang treats id as a built-in type
    /// when compiling Objective-C code, so this may be an opaque pointer (i8*),
    /// but if the runtime header declaring it is included then it may be a
    /// pointer to a structure.
    llvm::PointerType *IdTy;
    /// Pointer to a pointer to an Objective-C object.  Used in the new ABI
    /// message lookup function and some GC-related functions.
    llvm::PointerType *PtrToIdTy;
    /// The clang type of id.  Used when using the clang CGCall infrastructure to
    /// call Objective-C methods.
    CanQualType ASTIdTy;
    /// LLVM type for C int type.
    llvm::IntegerType *IntTy;
    /// LLVM type for an opaque pointer.  This is identical to PtrToInt8Ty, but is
    /// used in the code to document the difference between i8* meaning a pointer
    /// to a C string and i8* meaning a pointer to some opaque type.
    llvm::PointerType *PtrTy;
    /// LLVM type for C long type.  The runtime uses this in a lot of places where
    /// it should be using intptr_t, but we can't fix this without breaking
    /// compatibility with GCC...
    llvm::IntegerType *LongTy;
    /// LLVM type for C size_t.  Used in various runtime data structures.
    llvm::IntegerType *SizeTy;
    /// LLVM type for C intptr_t.
    llvm::IntegerType *IntPtrTy;
    /// LLVM type for C ptrdiff_t.  Mainly used in property accessor functions.
    llvm::IntegerType *PtrDiffTy;
    /// LLVM type for C int*.  Used for GCC-ABI-compatible non-fragile instance
    /// variables.
    llvm::PointerType *PtrToIntTy;
    /// LLVM type for Objective-C BOOL type.
    llvm::Type *BoolTy;
    /// 32-bit integer type, to save us needing to look it up every time it's used.
    llvm::IntegerType *Int32Ty;
    /// 64-bit integer type, to save us needing to look it up every time it's used.
    llvm::IntegerType *Int64Ty;
    /// The type of struct objc_property.
    llvm::StructType *PropertyMetadataTy;
    /// Metadata kind used to tie method lookups to message sends.  The GNUstep
    /// runtime provides some LLVM passes that can use this to do things like
    /// automatic IMP caching and speculative inlining.
    unsigned msgSendMDKind;
    /// Does the current target use SEH-based exceptions? False implies
    /// Itanium-style DWARF unwinding.
    bool usesSEHExceptions;
  
    /// Helper to check if we are targeting a specific runtime version or later.
    bool isRuntime(ObjCRuntime::Kind kind, unsigned major, unsigned minor=0) {
      const ObjCRuntime &R = CGM.getLangOpts().ObjCRuntime;
      return (R.getKind() == kind) &&
        (R.getVersion() >= VersionTuple(major, minor));
    }
  
    std::string ManglePublicSymbol(StringRef Name) {
      return (StringRef(CGM.getTriple().isOSBinFormatCOFF() ? "$_" : "._") + Name).str();
    }
  
    std::string SymbolForProtocol(Twine Name) {
      return (ManglePublicSymbol("OBJC_PROTOCOL_") + Name).str();
    }
  
    std::string SymbolForProtocolRef(StringRef Name) {
      return (ManglePublicSymbol("OBJC_REF_PROTOCOL_") + Name).str();
    }
  
  
    /// Helper function that generates a constant string and returns a pointer to
    /// the start of the string.  The result of this function can be used anywhere
    /// where the C code specifies const char*.
    llvm::Constant *MakeConstantString(StringRef Str, const char *Name = "") {
      ConstantAddress Array = CGM.GetAddrOfConstantCString(Str, Name);
      return llvm::ConstantExpr::getGetElementPtr(Array.getElementType(),
                                                  Array.getPointer(), Zeros);
    }
  
    /// Emits a linkonce_odr string, whose name is the prefix followed by the
    /// string value.  This allows the linker to combine the strings between
    /// different modules.  Used for EH typeinfo names, selector strings, and a
    /// few other things.
    llvm::Constant *ExportUniqueString(const std::string &Str,
                                       const std::string &prefix,
                                       bool Private=false) {
      std::string name = prefix + Str;
      auto *ConstStr = TheModule.getGlobalVariable(name);
      if (!ConstStr) {
        llvm::Constant *value = llvm::ConstantDataArray::getString(VMContext,Str);
        auto *GV = new llvm::GlobalVariable(TheModule, value->getType(), true,
                llvm::GlobalValue::LinkOnceODRLinkage, value, name);
        GV->setComdat(TheModule.getOrInsertComdat(name));
        if (Private)
          GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
        ConstStr = GV;
      }
      return llvm::ConstantExpr::getGetElementPtr(ConstStr->getValueType(),
                                                  ConstStr, Zeros);
    }
  
    /// Returns a property name and encoding string.
    llvm::Constant *MakePropertyEncodingString(const ObjCPropertyDecl *PD,
                                               const Decl *Container) {
      assert(!isRuntime(ObjCRuntime::GNUstep, 2));
      if (isRuntime(ObjCRuntime::GNUstep, 1, 6)) {
        std::string NameAndAttributes;
        std::string TypeStr =
          CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container);
        NameAndAttributes += '\0';
        NameAndAttributes += TypeStr.length() + 3;
        NameAndAttributes += TypeStr;
        NameAndAttributes += '\0';
        NameAndAttributes += PD->getNameAsString();
        return MakeConstantString(NameAndAttributes);
      }
      return MakeConstantString(PD->getNameAsString());
    }
  
    /// Push the property attributes into two structure fields.
    void PushPropertyAttributes(ConstantStructBuilder &Fields,
        const ObjCPropertyDecl *property, bool isSynthesized=true, bool
        isDynamic=true) {
      int attrs = property->getPropertyAttributes();
      // For read-only properties, clear the copy and retain flags
      if (attrs & ObjCPropertyDecl::OBJC_PR_readonly) {
        attrs &= ~ObjCPropertyDecl::OBJC_PR_copy;
        attrs &= ~ObjCPropertyDecl::OBJC_PR_retain;
        attrs &= ~ObjCPropertyDecl::OBJC_PR_weak;
        attrs &= ~ObjCPropertyDecl::OBJC_PR_strong;
      }
      // The first flags field has the same attribute values as clang uses internally
      Fields.addInt(Int8Ty, attrs & 0xff);
      attrs >>= 8;
      attrs <<= 2;
      // For protocol properties, synthesized and dynamic have no meaning, so we
      // reuse these flags to indicate that this is a protocol property (both set
      // has no meaning, as a property can't be both synthesized and dynamic)
      attrs |= isSynthesized ? (1<<0) : 0;
      attrs |= isDynamic ? (1<<1) : 0;
      // The second field is the next four fields left shifted by two, with the
      // low bit set to indicate whether the field is synthesized or dynamic.
      Fields.addInt(Int8Ty, attrs & 0xff);
      // Two padding fields
      Fields.addInt(Int8Ty, 0);
      Fields.addInt(Int8Ty, 0);
    }
  
    virtual llvm::Constant *GenerateCategoryProtocolList(const
        ObjCCategoryDecl *OCD);
    virtual ConstantArrayBuilder PushPropertyListHeader(ConstantStructBuilder &Fields,
        int count) {
        // int count;
        Fields.addInt(IntTy, count);
        // int size; (only in GNUstep v2 ABI.
        if (isRuntime(ObjCRuntime::GNUstep, 2)) {
          llvm::DataLayout td(&TheModule);
          Fields.addInt(IntTy, td.getTypeSizeInBits(PropertyMetadataTy) /
              CGM.getContext().getCharWidth());
        }
        // struct objc_property_list *next;
        Fields.add(NULLPtr);
        // struct objc_property properties[]
        return Fields.beginArray(PropertyMetadataTy);
    }
    virtual void PushProperty(ConstantArrayBuilder &PropertiesArray,
              const ObjCPropertyDecl *property,
              const Decl *OCD,
              bool isSynthesized=true, bool
              isDynamic=true) {
      auto Fields = PropertiesArray.beginStruct(PropertyMetadataTy);
      ASTContext &Context = CGM.getContext();
      Fields.add(MakePropertyEncodingString(property, OCD));
      PushPropertyAttributes(Fields, property, isSynthesized, isDynamic);
      auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) {
        if (accessor) {
          std::string TypeStr = Context.getObjCEncodingForMethodDecl(accessor);
          llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
          Fields.add(MakeConstantString(accessor->getSelector().getAsString()));
          Fields.add(TypeEncoding);
        } else {
          Fields.add(NULLPtr);
          Fields.add(NULLPtr);
        }
      };
      addPropertyMethod(property->getGetterMethodDecl());
      addPropertyMethod(property->getSetterMethodDecl());
      Fields.finishAndAddTo(PropertiesArray);
    }
  
    /// Ensures that the value has the required type, by inserting a bitcast if
    /// required.  This function lets us avoid inserting bitcasts that are
    /// redundant.
    llvm::Value* EnforceType(CGBuilderTy &B, llvm::Value *V, llvm::Type *Ty) {
      if (V->getType() == Ty) return V;
      return B.CreateBitCast(V, Ty);
    }
    Address EnforceType(CGBuilderTy &B, Address V, llvm::Type *Ty) {
      if (V.getType() == Ty) return V;
      return B.CreateBitCast(V, Ty);
    }
  
    // Some zeros used for GEPs in lots of places.
    llvm::Constant *Zeros[2];
    /// Null pointer value.  Mainly used as a terminator in various arrays.
    llvm::Constant *NULLPtr;
    /// LLVM context.
    llvm::LLVMContext &VMContext;
  
  protected:
  
    /// Placeholder for the class.  Lots of things refer to the class before we've
    /// actually emitted it.  We use this alias as a placeholder, and then replace
    /// it with a pointer to the class structure before finally emitting the
    /// module.
    llvm::GlobalAlias *ClassPtrAlias;
    /// Placeholder for the metaclass.  Lots of things refer to the class before
    /// we've / actually emitted it.  We use this alias as a placeholder, and then
    /// replace / it with a pointer to the metaclass structure before finally
    /// emitting the / module.
    llvm::GlobalAlias *MetaClassPtrAlias;
    /// All of the classes that have been generated for this compilation units.
    std::vector<llvm::Constant*> Classes;
    /// All of the categories that have been generated for this compilation units.
    std::vector<llvm::Constant*> Categories;
    /// All of the Objective-C constant strings that have been generated for this
    /// compilation units.
    std::vector<llvm::Constant*> ConstantStrings;
    /// Map from string values to Objective-C constant strings in the output.
    /// Used to prevent emitting Objective-C strings more than once.  This should
    /// not be required at all - CodeGenModule should manage this list.
    llvm::StringMap<llvm::Constant*> ObjCStrings;
    /// All of the protocols that have been declared.
    llvm::StringMap<llvm::Constant*> ExistingProtocols;
    /// For each variant of a selector, we store the type encoding and a
    /// placeholder value.  For an untyped selector, the type will be the empty
    /// string.  Selector references are all done via the module's selector table,
    /// so we create an alias as a placeholder and then replace it with the real
    /// value later.
    typedef std::pair<std::string, llvm::GlobalAlias*> TypedSelector;
    /// Type of the selector map.  This is roughly equivalent to the structure
    /// used in the GNUstep runtime, which maintains a list of all of the valid
    /// types for a selector in a table.
    typedef llvm::DenseMap<Selector, SmallVector<TypedSelector, 2> >
      SelectorMap;
    /// A map from selectors to selector types.  This allows us to emit all
    /// selectors of the same name and type together.
    SelectorMap SelectorTable;
  
    /// Selectors related to memory management.  When compiling in GC mode, we
    /// omit these.
    Selector RetainSel, ReleaseSel, AutoreleaseSel;
    /// Runtime functions used for memory management in GC mode.  Note that clang
    /// supports code generation for calling these functions, but neither GNU
    /// runtime actually supports this API properly yet.
    LazyRuntimeFunction IvarAssignFn, StrongCastAssignFn, MemMoveFn, WeakReadFn,
      WeakAssignFn, GlobalAssignFn;
  
    typedef std::pair<std::string, std::string> ClassAliasPair;
    /// All classes that have aliases set for them.
    std::vector<ClassAliasPair> ClassAliases;
  
  protected:
    /// Function used for throwing Objective-C exceptions.
    LazyRuntimeFunction ExceptionThrowFn;
    /// Function used for rethrowing exceptions, used at the end of \@finally or
    /// \@synchronize blocks.
    LazyRuntimeFunction ExceptionReThrowFn;
    /// Function called when entering a catch function.  This is required for
    /// differentiating Objective-C exceptions and foreign exceptions.
    LazyRuntimeFunction EnterCatchFn;
    /// Function called when exiting from a catch block.  Used to do exception
    /// cleanup.
    LazyRuntimeFunction ExitCatchFn;
    /// Function called when entering an \@synchronize block.  Acquires the lock.
    LazyRuntimeFunction SyncEnterFn;
    /// Function called when exiting an \@synchronize block.  Releases the lock.
    LazyRuntimeFunction SyncExitFn;
  
  private:
    /// Function called if fast enumeration detects that the collection is
    /// modified during the update.
    LazyRuntimeFunction EnumerationMutationFn;
    /// Function for implementing synthesized property getters that return an
    /// object.
    LazyRuntimeFunction GetPropertyFn;
    /// Function for implementing synthesized property setters that return an
    /// object.
    LazyRuntimeFunction SetPropertyFn;
    /// Function used for non-object declared property getters.
    LazyRuntimeFunction GetStructPropertyFn;
    /// Function used for non-object declared property setters.
    LazyRuntimeFunction SetStructPropertyFn;
  
  protected:
    /// The version of the runtime that this class targets.  Must match the
    /// version in the runtime.
    int RuntimeVersion;
    /// The version of the protocol class.  Used to differentiate between ObjC1
    /// and ObjC2 protocols.  Objective-C 1 protocols can not contain optional
    /// components and can not contain declared properties.  We always emit
    /// Objective-C 2 property structures, but we have to pretend that they're
    /// Objective-C 1 property structures when targeting the GCC runtime or it
    /// will abort.
    const int ProtocolVersion;
    /// The version of the class ABI.  This value is used in the class structure
    /// and indicates how various fields should be interpreted.
    const int ClassABIVersion;
    /// Generates an instance variable list structure.  This is a structure
    /// containing a size and an array of structures containing instance variable
    /// metadata.  This is used purely for introspection in the fragile ABI.  In
    /// the non-fragile ABI, it's used for instance variable fixup.
    virtual llvm::Constant *GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames,
                               ArrayRef<llvm::Constant *> IvarTypes,
                               ArrayRef<llvm::Constant *> IvarOffsets,
                               ArrayRef<llvm::Constant *> IvarAlign,
                               ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership);
  
    /// Generates a method list structure.  This is a structure containing a size
    /// and an array of structures containing method metadata.
    ///
    /// This structure is used by both classes and categories, and contains a next
    /// pointer allowing them to be chained together in a linked list.
    llvm::Constant *GenerateMethodList(StringRef ClassName,
        StringRef CategoryName,
        ArrayRef<const ObjCMethodDecl*> Methods,
        bool isClassMethodList);
  
    /// Emits an empty protocol.  This is used for \@protocol() where no protocol
    /// is found.  The runtime will (hopefully) fix up the pointer to refer to the
    /// real protocol.
    virtual llvm::Constant *GenerateEmptyProtocol(StringRef ProtocolName);
  
    /// Generates a list of property metadata structures.  This follows the same
    /// pattern as method and instance variable metadata lists.
    llvm::Constant *GeneratePropertyList(const Decl *Container,
        const ObjCContainerDecl *OCD,
        bool isClassProperty=false,
        bool protocolOptionalProperties=false);
  
    /// Generates a list of referenced protocols.  Classes, categories, and
    /// protocols all use this structure.
    llvm::Constant *GenerateProtocolList(ArrayRef<std::string> Protocols);
  
    /// To ensure that all protocols are seen by the runtime, we add a category on
    /// a class defined in the runtime, declaring no methods, but adopting the
    /// protocols.  This is a horribly ugly hack, but it allows us to collect all
    /// of the protocols without changing the ABI.
    void GenerateProtocolHolderCategory();
  
    /// Generates a class structure.
    llvm::Constant *GenerateClassStructure(
        llvm::Constant *MetaClass,
        llvm::Constant *SuperClass,
        unsigned info,
        const char *Name,
        llvm::Constant *Version,
        llvm::Constant *InstanceSize,
        llvm::Constant *IVars,
        llvm::Constant *Methods,
        llvm::Constant *Protocols,
        llvm::Constant *IvarOffsets,
        llvm::Constant *Properties,
        llvm::Constant *StrongIvarBitmap,
        llvm::Constant *WeakIvarBitmap,
        bool isMeta=false);
  
    /// Generates a method list.  This is used by protocols to define the required
    /// and optional methods.
    virtual llvm::Constant *GenerateProtocolMethodList(
        ArrayRef<const ObjCMethodDecl*> Methods);
    /// Emits optional and required method lists.
    template<class T>
    void EmitProtocolMethodList(T &&Methods, llvm::Constant *&Required,
        llvm::Constant *&Optional) {
      SmallVector<const ObjCMethodDecl*, 16> RequiredMethods;
      SmallVector<const ObjCMethodDecl*, 16> OptionalMethods;
      for (const auto *I : Methods)
        if (I->isOptional())
          OptionalMethods.push_back(I);
        else
          RequiredMethods.push_back(I);
      Required = GenerateProtocolMethodList(RequiredMethods);
      Optional = GenerateProtocolMethodList(OptionalMethods);
    }
  
    /// Returns a selector with the specified type encoding.  An empty string is
    /// used to return an untyped selector (with the types field set to NULL).
    virtual llvm::Value *GetTypedSelector(CodeGenFunction &CGF, Selector Sel,
                                          const std::string &TypeEncoding);
  
    /// Returns the name of ivar offset variables.  In the GNUstep v1 ABI, this
    /// contains the class and ivar names, in the v2 ABI this contains the type
    /// encoding as well.
    virtual std::string GetIVarOffsetVariableName(const ObjCInterfaceDecl *ID,
                                                  const ObjCIvarDecl *Ivar) {
      const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString()
        + '.' + Ivar->getNameAsString();
      return Name;
    }
    /// Returns the variable used to store the offset of an instance variable.
    llvm::GlobalVariable *ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
        const ObjCIvarDecl *Ivar);
    /// Emits a reference to a class.  This allows the linker to object if there
    /// is no class of the matching name.
    void EmitClassRef(const std::string &className);
  
    /// Emits a pointer to the named class
    virtual llvm::Value *GetClassNamed(CodeGenFunction &CGF,
                                       const std::string &Name, bool isWeak);
  
    /// Looks up the method for sending a message to the specified object.  This
    /// mechanism differs between the GCC and GNU runtimes, so this method must be
    /// overridden in subclasses.
    virtual llvm::Value *LookupIMP(CodeGenFunction &CGF,
                                   llvm::Value *&Receiver,
                                   llvm::Value *cmd,
                                   llvm::MDNode *node,
                                   MessageSendInfo &MSI) = 0;
  
    /// Looks up the method for sending a message to a superclass.  This
    /// mechanism differs between the GCC and GNU runtimes, so this method must
    /// be overridden in subclasses.
    virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF,
                                        Address ObjCSuper,
                                        llvm::Value *cmd,
                                        MessageSendInfo &MSI) = 0;
  
    /// Libobjc2 uses a bitfield representation where small(ish) bitfields are
    /// stored in a 64-bit value with the low bit set to 1 and the remaining 63
    /// bits set to their values, LSB first, while larger ones are stored in a
    /// structure of this / form:
    ///
    /// struct { int32_t length; int32_t values[length]; };
    ///
    /// The values in the array are stored in host-endian format, with the least
    /// significant bit being assumed to come first in the bitfield.  Therefore,
    /// a bitfield with the 64th bit set will be (int64_t)&{ 2, [0, 1<<31] },
    /// while a bitfield / with the 63rd bit set will be 1<<64.
    llvm::Constant *MakeBitField(ArrayRef<bool> bits);
  
  public:
    CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion,
        unsigned protocolClassVersion, unsigned classABI=1);
  
    ConstantAddress GenerateConstantString(const StringLiteral *) override;
  
    RValue
    GenerateMessageSend(CodeGenFunction &CGF, ReturnValueSlot Return,
                        QualType ResultType, Selector Sel,
                        llvm::Value *Receiver, const CallArgList &CallArgs,
                        const ObjCInterfaceDecl *Class,
                        const ObjCMethodDecl *Method) override;
    RValue
    GenerateMessageSendSuper(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 *OID) override;
    llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override;
    Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
    llvm::Value *GetSelector(CodeGenFunction &CGF,
                             const ObjCMethodDecl *Method) override;
    virtual llvm::Constant *GetConstantSelector(Selector Sel,
                                                const std::string &TypeEncoding) {
      llvm_unreachable("Runtime unable to generate constant selector");
    }
    llvm::Constant *GetConstantSelector(const ObjCMethodDecl *M) {
      return GetConstantSelector(M->getSelector(),
          CGM.getContext().getObjCEncodingForMethodDecl(M));
    }
    llvm::Constant *GetEHType(QualType T) override;
  
    llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
                                   const ObjCContainerDecl *CD) 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;
    void GenerateProtocol(const ObjCProtocolDecl *PD) override;
    llvm::Function *ModuleInitFunction() override;
    llvm::FunctionCallee GetPropertyGetFunction() override;
    llvm::FunctionCallee GetPropertySetFunction() override;
    llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
                                                         bool copy) override;
    llvm::FunctionCallee GetSetStructFunction() override;
    llvm::FunctionCallee GetGetStructFunction() override;
    llvm::FunctionCallee GetCppAtomicObjectGetFunction() override;
    llvm::FunctionCallee GetCppAtomicObjectSetFunction() override;
    llvm::FunctionCallee EnumerationMutationFunction() override;
  
    void EmitTryStmt(CodeGenFunction &CGF,
                     const ObjCAtTryStmt &S) override;
    void EmitSynchronizedStmt(CodeGenFunction &CGF,
                              const ObjCAtSynchronizedStmt &S) override;
    void EmitThrowStmt(CodeGenFunction &CGF,
                       const ObjCAtThrowStmt &S,
                       bool ClearInsertionPoint=true) override;
    llvm::Value * EmitObjCWeakRead(CodeGenFunction &CGF,
                                   Address AddrWeakObj) override;
    void EmitObjCWeakAssign(CodeGenFunction &CGF,
                            llvm::Value *src, Address dst) override;
    void EmitObjCGlobalAssign(CodeGenFunction &CGF,
                              llvm::Value *src, Address dest,
                              bool threadlocal=false) override;
    void EmitObjCIvarAssign(CodeGenFunction &CGF, llvm::Value *src,
                            Address dest, llvm::Value *ivarOffset) override;
    void EmitObjCStrongCastAssign(CodeGenFunction &CGF,
                                  llvm::Value *src, Address dest) override;
    void EmitGCMemmoveCollectable(CodeGenFunction &CGF, Address DestPtr,
                                  Address SrcPtr,
                                  llvm::Value *Size) override;
    LValue EmitObjCValueForIvar(CodeGenFunction &CGF, QualType ObjectTy,
                                llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
                                unsigned CVRQualifiers) override;
    llvm::Value *EmitIvarOffset(CodeGenFunction &CGF,
                                const ObjCInterfaceDecl *Interface,
                                const ObjCIvarDecl *Ivar) override;
    llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
    llvm::Constant *BuildGCBlockLayout(CodeGenModule &CGM,
                                       const CGBlockInfo &blockInfo) override {
      return NULLPtr;
    }
    llvm::Constant *BuildRCBlockLayout(CodeGenModule &CGM,
                                       const CGBlockInfo &blockInfo) override {
      return NULLPtr;
    }
  
    llvm::Constant *BuildByrefLayout(CodeGenModule &CGM, QualType T) override {
      return NULLPtr;
    }
  };
  
  /// Class representing the legacy GCC Objective-C ABI.  This is the default when
  /// -fobjc-nonfragile-abi is not specified.
  ///
  /// The GCC ABI target actually generates code that is approximately compatible
  /// with the new GNUstep runtime ABI, but refrains from using any features that
  /// would not work with the GCC runtime.  For example, clang always generates
  /// the extended form of the class structure, and the extra fields are simply
  /// ignored by GCC libobjc.
  class CGObjCGCC : public CGObjCGNU {
    /// The GCC ABI message lookup function.  Returns an IMP pointing to the
    /// method implementation for this message.
    LazyRuntimeFunction MsgLookupFn;
    /// The GCC ABI superclass message lookup function.  Takes a pointer to a
    /// structure describing the receiver and the class, and a selector as
    /// arguments.  Returns the IMP for the corresponding method.
    LazyRuntimeFunction MsgLookupSuperFn;
  
  protected:
    llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver,
                           llvm::Value *cmd, llvm::MDNode *node,
                           MessageSendInfo &MSI) override {
      CGBuilderTy &Builder = CGF.Builder;
      llvm::Value *args[] = {
              EnforceType(Builder, Receiver, IdTy),
              EnforceType(Builder, cmd, SelectorTy) };
      llvm::CallBase *imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFn, args);
      imp->setMetadata(msgSendMDKind, node);
      return imp;
    }
  
    llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
                                llvm::Value *cmd, MessageSendInfo &MSI) override {
      CGBuilderTy &Builder = CGF.Builder;
      llvm::Value *lookupArgs[] = {EnforceType(Builder, ObjCSuper,
          PtrToObjCSuperTy).getPointer(), cmd};
      return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs);
    }
  
  public:
    CGObjCGCC(CodeGenModule &Mod) : CGObjCGNU(Mod, 8, 2) {
      // IMP objc_msg_lookup(id, SEL);
      MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy);
      // IMP objc_msg_lookup_super(struct objc_super*, SEL);
      MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
                            PtrToObjCSuperTy, SelectorTy);
    }
  };
  
  /// Class used when targeting the new GNUstep runtime ABI.
  class CGObjCGNUstep : public CGObjCGNU {
      /// The slot lookup function.  Returns a pointer to a cacheable structure
      /// that contains (among other things) the IMP.
      LazyRuntimeFunction SlotLookupFn;
      /// The GNUstep ABI superclass message lookup function.  Takes a pointer to
      /// a structure describing the receiver and the class, and a selector as
      /// arguments.  Returns the slot for the corresponding method.  Superclass
      /// message lookup rarely changes, so this is a good caching opportunity.
      LazyRuntimeFunction SlotLookupSuperFn;
      /// Specialised function for setting atomic retain properties
      LazyRuntimeFunction SetPropertyAtomic;
      /// Specialised function for setting atomic copy properties
      LazyRuntimeFunction SetPropertyAtomicCopy;
      /// Specialised function for setting nonatomic retain properties
      LazyRuntimeFunction SetPropertyNonAtomic;
      /// Specialised function for setting nonatomic copy properties
      LazyRuntimeFunction SetPropertyNonAtomicCopy;
      /// Function to perform atomic copies of C++ objects with nontrivial copy
      /// constructors from Objective-C ivars.
      LazyRuntimeFunction CxxAtomicObjectGetFn;
      /// Function to perform atomic copies of C++ objects with nontrivial copy
      /// constructors to Objective-C ivars.
      LazyRuntimeFunction CxxAtomicObjectSetFn;
      /// Type of an slot structure pointer.  This is returned by the various
      /// lookup functions.
      llvm::Type *SlotTy;
  
    public:
      llvm::Constant *GetEHType(QualType T) override;
  
    protected:
      llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver,
                             llvm::Value *cmd, llvm::MDNode *node,
                             MessageSendInfo &MSI) override {
        CGBuilderTy &Builder = CGF.Builder;
        llvm::FunctionCallee LookupFn = SlotLookupFn;
  
        // Store the receiver on the stack so that we can reload it later
        Address ReceiverPtr =
          CGF.CreateTempAlloca(Receiver->getType(), CGF.getPointerAlign());
        Builder.CreateStore(Receiver, ReceiverPtr);
  
        llvm::Value *self;
  
        if (isa<ObjCMethodDecl>(CGF.CurCodeDecl)) {
          self = CGF.LoadObjCSelf();
        } else {
          self = llvm::ConstantPointerNull::get(IdTy);
        }
  
        // The lookup function is guaranteed not to capture the receiver pointer.
        if (auto *LookupFn2 = dyn_cast<llvm::Function>(LookupFn.getCallee()))
          LookupFn2->addParamAttr(0, llvm::Attribute::NoCapture);
  
        llvm::Value *args[] = {
                EnforceType(Builder, ReceiverPtr.getPointer(), PtrToIdTy),
                EnforceType(Builder, cmd, SelectorTy),
                EnforceType(Builder, self, IdTy) };
        llvm::CallBase *slot = CGF.EmitRuntimeCallOrInvoke(LookupFn, args);
        slot->setOnlyReadsMemory();
        slot->setMetadata(msgSendMDKind, node);
  
        // Load the imp from the slot
        llvm::Value *imp = Builder.CreateAlignedLoad(
            Builder.CreateStructGEP(nullptr, slot, 4), CGF.getPointerAlign());
  
        // The lookup function may have changed the receiver, so make sure we use
        // the new one.
        Receiver = Builder.CreateLoad(ReceiverPtr, true);
        return imp;
      }
  
      llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
                                  llvm::Value *cmd,
                                  MessageSendInfo &MSI) override {
        CGBuilderTy &Builder = CGF.Builder;
        llvm::Value *lookupArgs[] = {ObjCSuper.getPointer(), cmd};
  
        llvm::CallInst *slot =
          CGF.EmitNounwindRuntimeCall(SlotLookupSuperFn, lookupArgs);
        slot->setOnlyReadsMemory();
  
        return Builder.CreateAlignedLoad(Builder.CreateStructGEP(nullptr, slot, 4),
                                         CGF.getPointerAlign());
      }
  
    public:
      CGObjCGNUstep(CodeGenModule &Mod) : CGObjCGNUstep(Mod, 9, 3, 1) {}
      CGObjCGNUstep(CodeGenModule &Mod, unsigned ABI, unsigned ProtocolABI,
          unsigned ClassABI) :
        CGObjCGNU(Mod, ABI, ProtocolABI, ClassABI) {
        const ObjCRuntime &R = CGM.getLangOpts().ObjCRuntime;
  
        llvm::StructType *SlotStructTy =
            llvm::StructType::get(PtrTy, PtrTy, PtrTy, IntTy, IMPTy);
        SlotTy = llvm::PointerType::getUnqual(SlotStructTy);
        // Slot_t objc_msg_lookup_sender(id *receiver, SEL selector, id sender);
        SlotLookupFn.init(&CGM, "objc_msg_lookup_sender", SlotTy, PtrToIdTy,
                          SelectorTy, IdTy);
        // Slot_t objc_slot_lookup_super(struct objc_super*, SEL);
        SlotLookupSuperFn.init(&CGM, "objc_slot_lookup_super", SlotTy,
                               PtrToObjCSuperTy, SelectorTy);
        // If we're in ObjC++ mode, then we want to make 
        if (usesSEHExceptions) {
            llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
            // void objc_exception_rethrow(void)
            ExceptionReThrowFn.init(&CGM, "objc_exception_rethrow", VoidTy);
        } else if (CGM.getLangOpts().CPlusPlus) {
          llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
          // void *__cxa_begin_catch(void *e)
          EnterCatchFn.init(&CGM, "__cxa_begin_catch", PtrTy, PtrTy);
          // void __cxa_end_catch(void)
          ExitCatchFn.init(&CGM, "__cxa_end_catch", VoidTy);
          // void _Unwind_Resume_or_Rethrow(void*)
          ExceptionReThrowFn.init(&CGM, "_Unwind_Resume_or_Rethrow", VoidTy,
                                  PtrTy);
        } else if (R.getVersion() >= VersionTuple(1, 7)) {
          llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
          // id objc_begin_catch(void *e)
          EnterCatchFn.init(&CGM, "objc_begin_catch", IdTy, PtrTy);
          // void objc_end_catch(void)
          ExitCatchFn.init(&CGM, "objc_end_catch", VoidTy);
          // void _Unwind_Resume_or_Rethrow(void*)
          ExceptionReThrowFn.init(&CGM, "objc_exception_rethrow", VoidTy, PtrTy);
        }
        llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
        SetPropertyAtomic.init(&CGM, "objc_setProperty_atomic", VoidTy, IdTy,
                               SelectorTy, IdTy, PtrDiffTy);
        SetPropertyAtomicCopy.init(&CGM, "objc_setProperty_atomic_copy", VoidTy,
                                   IdTy, SelectorTy, IdTy, PtrDiffTy);
        SetPropertyNonAtomic.init(&CGM, "objc_setProperty_nonatomic", VoidTy,
                                  IdTy, SelectorTy, IdTy, PtrDiffTy);
        SetPropertyNonAtomicCopy.init(&CGM, "objc_setProperty_nonatomic_copy",
                                      VoidTy, IdTy, SelectorTy, IdTy, PtrDiffTy);
        // void objc_setCppObjectAtomic(void *dest, const void *src, void
        // *helper);
        CxxAtomicObjectSetFn.init(&CGM, "objc_setCppObjectAtomic", VoidTy, PtrTy,
                                  PtrTy, PtrTy);
        // void objc_getCppObjectAtomic(void *dest, const void *src, void
        // *helper);
        CxxAtomicObjectGetFn.init(&CGM, "objc_getCppObjectAtomic", VoidTy, PtrTy,
                                  PtrTy, PtrTy);
      }
  
      llvm::FunctionCallee GetCppAtomicObjectGetFunction() override {
        // The optimised functions were added in version 1.7 of the GNUstep
        // runtime.
        assert (CGM.getLangOpts().ObjCRuntime.getVersion() >=
            VersionTuple(1, 7));
        return CxxAtomicObjectGetFn;
      }
  
      llvm::FunctionCallee GetCppAtomicObjectSetFunction() override {
        // The optimised functions were added in version 1.7 of the GNUstep
        // runtime.
        assert (CGM.getLangOpts().ObjCRuntime.getVersion() >=
            VersionTuple(1, 7));
        return CxxAtomicObjectSetFn;
      }
  
      llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
                                                           bool copy) override {
        // The optimised property functions omit the GC check, and so are not
        // safe to use in GC mode.  The standard functions are fast in GC mode,
        // so there is less advantage in using them.
        assert ((CGM.getLangOpts().getGC() == LangOptions::NonGC));
        // The optimised functions were added in version 1.7 of the GNUstep
        // runtime.
        assert (CGM.getLangOpts().ObjCRuntime.getVersion() >=
            VersionTuple(1, 7));
  
        if (atomic) {
          if (copy) return SetPropertyAtomicCopy;
          return SetPropertyAtomic;
        }
  
        return copy ? SetPropertyNonAtomicCopy : SetPropertyNonAtomic;
      }
  };
  
  /// GNUstep Objective-C ABI version 2 implementation.
  /// This is the ABI that provides a clean break with the legacy GCC ABI and
  /// cleans up a number of things that were added to work around 1980s linkers.
  class CGObjCGNUstep2 : public CGObjCGNUstep {
    enum SectionKind
    {
      SelectorSection = 0,
      ClassSection,
      ClassReferenceSection,
      CategorySection,
      ProtocolSection,
      ProtocolReferenceSection,
      ClassAliasSection,
      ConstantStringSection
    };
    static const char *const SectionsBaseNames[8];
    static const char *const PECOFFSectionsBaseNames[8];
    template<SectionKind K>
    std::string sectionName() {
      if (CGM.getTriple().isOSBinFormatCOFF()) {
        std::string name(PECOFFSectionsBaseNames[K]);
        name += "$m";
        return name;
      }
      return SectionsBaseNames[K];
    }
    /// The GCC ABI superclass message lookup function.  Takes a pointer to a
    /// structure describing the receiver and the class, and a selector as
    /// arguments.  Returns the IMP for the corresponding method.
    LazyRuntimeFunction MsgLookupSuperFn;
    /// A flag indicating if we've emitted at least one protocol.
    /// If we haven't, then we need to emit an empty protocol, to ensure that the
    /// __start__objc_protocols and __stop__objc_protocols sections exist.
    bool EmittedProtocol = false;
    /// A flag indicating if we've emitted at least one protocol reference.
    /// If we haven't, then we need to emit an empty protocol, to ensure that the
    /// __start__objc_protocol_refs and __stop__objc_protocol_refs sections
    /// exist.
    bool EmittedProtocolRef = false;
    /// A flag indicating if we've emitted at least one class.
    /// If we haven't, then we need to emit an empty protocol, to ensure that the
    /// __start__objc_classes and __stop__objc_classes sections / exist.
    bool EmittedClass = false;
    /// Generate the name of a symbol for a reference to a class.  Accesses to
    /// classes should be indirected via this.
  
    typedef std::pair<std::string, std::pair<llvm::Constant*, int>> EarlyInitPair;
    std::vector<EarlyInitPair> EarlyInitList;
  
    std::string SymbolForClassRef(StringRef Name, bool isWeak) {
      if (isWeak)
        return (ManglePublicSymbol("OBJC_WEAK_REF_CLASS_") + Name).str();
      else
        return (ManglePublicSymbol("OBJC_REF_CLASS_") + Name).str();
    }
    /// Generate the name of a class symbol.
    std::string SymbolForClass(StringRef Name) {
      return (ManglePublicSymbol("OBJC_CLASS_") + Name).str();
    }
    void CallRuntimeFunction(CGBuilderTy &B, StringRef FunctionName,
        ArrayRef<llvm::Value*> Args) {
      SmallVector<llvm::Type *,8> Types;
      for (auto *Arg : Args)
        Types.push_back(Arg->getType());
      llvm::FunctionType *FT = llvm::FunctionType::get(B.getVoidTy(), Types,
          false);
      llvm::FunctionCallee Fn = CGM.CreateRuntimeFunction(FT, FunctionName);
      B.CreateCall(Fn, Args);
    }
  
    ConstantAddress GenerateConstantString(const StringLiteral *SL) override {
  
      auto Str = SL->getString();
      CharUnits Align = CGM.getPointerAlign();
  
      // Look for an existing one
      llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str);
      if (old != ObjCStrings.end())
        return ConstantAddress(old->getValue(), Align);
  
      bool isNonASCII = SL->containsNonAscii();
  
      auto LiteralLength = SL->getLength();
  
      if ((CGM.getTarget().getPointerWidth(0) == 64) &&
          (LiteralLength < 9) && !isNonASCII) {
        // Tiny strings are only used on 64-bit platforms.  They store 8 7-bit
        // ASCII characters in the high 56 bits, followed by a 4-bit length and a
        // 3-bit tag (which is always 4).
        uint64_t str = 0;
        // Fill in the characters
        for (unsigned i=0 ; i<LiteralLength ; i++)
          str |= ((uint64_t)SL->getCodeUnit(i)) << ((64 - 4 - 3) - (i*7));
        // Fill in the length
        str |= LiteralLength << 3;
        // Set the tag
        str |= 4;
        auto *ObjCStr = llvm::ConstantExpr::getIntToPtr(
            llvm::ConstantInt::get(Int64Ty, str), IdTy);
        ObjCStrings[Str] = ObjCStr;
        return ConstantAddress(ObjCStr, Align);
      }
  
      StringRef StringClass = CGM.getLangOpts().ObjCConstantStringClass;
  
      if (StringClass.empty()) StringClass = "NSConstantString";
  
      std::string Sym = SymbolForClass(StringClass);
  
      llvm::Constant *isa = TheModule.getNamedGlobal(Sym);
  
      if (!isa) {
        isa = new llvm::GlobalVariable(TheModule, IdTy, /* isConstant */false,
                llvm::GlobalValue::ExternalLinkage, nullptr, Sym);
        if (CGM.getTriple().isOSBinFormatCOFF()) {
          cast<llvm::GlobalValue>(isa)->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
        }
      } else if (isa->getType() != PtrToIdTy)
        isa = llvm::ConstantExpr::getBitCast(isa, PtrToIdTy);
  
      //  struct
      //  {
      //    Class isa;
      //    uint32_t flags;
      //    uint32_t length; // Number of codepoints
      //    uint32_t size; // Number of bytes
      //    uint32_t hash;
      //    const char *data;
      //  };
  
      ConstantInitBuilder Builder(CGM);
      auto Fields = Builder.beginStruct();
      if (!CGM.getTriple().isOSBinFormatCOFF()) {
        Fields.add(isa);
      } else {
        Fields.addNullPointer(PtrTy);
      }
      // For now, all non-ASCII strings are represented as UTF-16.  As such, the
      // number of bytes is simply double the number of UTF-16 codepoints.  In
      // ASCII strings, the number of bytes is equal to the number of non-ASCII
      // codepoints.
      if (isNonASCII) {
        unsigned NumU8CodeUnits = Str.size();
        // A UTF-16 representation of a unicode string contains at most the same
        // number of code units as a UTF-8 representation.  Allocate that much
        // space, plus one for the final null character.
        SmallVector<llvm::UTF16, 128> ToBuf(NumU8CodeUnits + 1);
        const llvm::UTF8 *FromPtr = (const llvm::UTF8 *)Str.data();
        llvm::UTF16 *ToPtr = &ToBuf[0];
        (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumU8CodeUnits,
            &ToPtr, ToPtr + NumU8CodeUnits, llvm::strictConversion);
        uint32_t StringLength = ToPtr - &ToBuf[0];
        // Add null terminator
        *ToPtr = 0;
        // Flags: 2 indicates UTF-16 encoding
        Fields.addInt(Int32Ty, 2);
        // Number of UTF-16 codepoints
        Fields.addInt(Int32Ty, StringLength);
        // Number of bytes
        Fields.addInt(Int32Ty, StringLength * 2);
        // Hash.  Not currently initialised by the compiler.
        Fields.addInt(Int32Ty, 0);
        // pointer to the data string.
        auto Arr = llvm::makeArrayRef(&ToBuf[0], ToPtr+1);
        auto *C = llvm::ConstantDataArray::get(VMContext, Arr);
        auto *Buffer = new llvm::GlobalVariable(TheModule, C->getType(),
            /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, C, ".str");
        Buffer->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
        Fields.add(Buffer);
      } else {
        // Flags: 0 indicates ASCII encoding
        Fields.addInt(Int32Ty, 0);
        // Number of UTF-16 codepoints, each ASCII byte is a UTF-16 codepoint
        Fields.addInt(Int32Ty, Str.size());
        // Number of bytes
        Fields.addInt(Int32Ty, Str.size());
        // Hash.  Not currently initialised by the compiler.
        Fields.addInt(Int32Ty, 0);
        // Data pointer
        Fields.add(MakeConstantString(Str));
      }
      std::string StringName;
      bool isNamed = !isNonASCII;
      if (isNamed) {
        StringName = ".objc_str_";
        for (int i=0,e=Str.size() ; i<e ; ++i) {
          unsigned char c = Str[i];
          if (isalnum(c))
            StringName += c;
          else if (c == ' ')
            StringName += '_';
          else {
            isNamed = false;
            break;
          }
        }
      }
      auto *ObjCStrGV =
        Fields.finishAndCreateGlobal(
            isNamed ? StringRef(StringName) : ".objc_string",
            Align, false, isNamed ? llvm::GlobalValue::LinkOnceODRLinkage
                                  : llvm::GlobalValue::PrivateLinkage);
      ObjCStrGV->setSection(sectionName<ConstantStringSection>());
      if (isNamed) {
        ObjCStrGV->setComdat(TheModule.getOrInsertComdat(StringName));
        ObjCStrGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
      }
      if (CGM.getTriple().isOSBinFormatCOFF()) {
        std::pair<llvm::Constant*, int> v{ObjCStrGV, 0};
        EarlyInitList.emplace_back(Sym, v);
      }
      llvm::Constant *ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStrGV, IdTy);
      ObjCStrings[Str] = ObjCStr;
      ConstantStrings.push_back(ObjCStr);
      return ConstantAddress(ObjCStr, Align);
    }
  
    void PushProperty(ConstantArrayBuilder &PropertiesArray,
              const ObjCPropertyDecl *property,
              const Decl *OCD,
              bool isSynthesized=true, bool
              isDynamic=true) override {
      // struct objc_property
      // {
      //   const char *name;
      //   const char *attributes;
      //   const char *type;
      //   SEL getter;
      //   SEL setter;
      // };
      auto Fields = PropertiesArray.beginStruct(PropertyMetadataTy);
      ASTContext &Context = CGM.getContext();
      Fields.add(MakeConstantString(property->getNameAsString()));
      std::string TypeStr =
        CGM.getContext().getObjCEncodingForPropertyDecl(property, OCD);
      Fields.add(MakeConstantString(TypeStr));
      std::string typeStr;
      Context.getObjCEncodingForType(property->getType(), typeStr);
      Fields.add(MakeConstantString(typeStr));
      auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) {
        if (accessor) {
          std::string TypeStr = Context.getObjCEncodingForMethodDecl(accessor);
          Fields.add(GetConstantSelector(accessor->getSelector(), TypeStr));
        } else {
          Fields.add(NULLPtr);
        }
      };
      addPropertyMethod(property->getGetterMethodDecl());
      addPropertyMethod(property->getSetterMethodDecl());
      Fields.finishAndAddTo(PropertiesArray);
    }
  
    llvm::Constant *
    GenerateProtocolMethodList(ArrayRef<const ObjCMethodDecl*> Methods) override {
      // struct objc_protocol_method_description
      // {
      //   SEL selector;
      //   const char *types;
      // };
      llvm::StructType *ObjCMethodDescTy =
        llvm::StructType::get(CGM.getLLVMContext(),
            { PtrToInt8Ty, PtrToInt8Ty });
      ASTContext &Context = CGM.getContext();
      ConstantInitBuilder Builder(CGM);
      // struct objc_protocol_method_description_list
      // {
      //   int count;
      //   int size;
      //   struct objc_protocol_method_description methods[];
      // };
      auto MethodList = Builder.beginStruct();
      // int count;
      MethodList.addInt(IntTy, Methods.size());
      // int size; // sizeof(struct objc_method_description)
      llvm::DataLayout td(&TheModule);
      MethodList.addInt(IntTy, td.getTypeSizeInBits(ObjCMethodDescTy) /
          CGM.getContext().getCharWidth());
      // struct objc_method_description[]
      auto MethodArray = MethodList.beginArray(ObjCMethodDescTy);
      for (auto *M : Methods) {
        auto Method = MethodArray.beginStruct(ObjCMethodDescTy);
        Method.add(CGObjCGNU::GetConstantSelector(M));
        Method.add(GetTypeString(Context.getObjCEncodingForMethodDecl(M, true)));
        Method.finishAndAddTo(MethodArray);
      }
      MethodArray.finishAndAddTo(MethodList);
      return MethodList.finishAndCreateGlobal(".objc_protocol_method_list",
                                              CGM.getPointerAlign());
    }
    llvm::Constant *GenerateCategoryProtocolList(const ObjCCategoryDecl *OCD)
      override {
      SmallVector<llvm::Constant*, 16> Protocols;
      for (const auto *PI : OCD->getReferencedProtocols())
        Protocols.push_back(
            llvm::ConstantExpr::getBitCast(GenerateProtocolRef(PI),
              ProtocolPtrTy));
      return GenerateProtocolList(Protocols);
    }
  
    llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
                                llvm::Value *cmd, MessageSendInfo &MSI) override {
      // Don't access the slot unless we're trying to cache the result.
      CGBuilderTy &Builder = CGF.Builder;
      llvm::Value *lookupArgs[] = {CGObjCGNU::EnforceType(Builder, ObjCSuper,
          PtrToObjCSuperTy).getPointer(), cmd};
      return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs);
    }
  
    llvm::GlobalVariable *GetClassVar(StringRef Name, bool isWeak=false) {
      std::string SymbolName = SymbolForClassRef(Name, isWeak);
      auto *ClassSymbol = TheModule.getNamedGlobal(SymbolName);
      if (ClassSymbol)
        return ClassSymbol;
      ClassSymbol = new llvm::GlobalVariable(TheModule,
          IdTy, false, llvm::GlobalValue::ExternalLinkage,
          nullptr, SymbolName);
      // If this is a weak symbol, then we are creating a valid definition for
      // the symbol, pointing to a weak definition of the real class pointer.  If
      // this is not a weak reference, then we are expecting another compilation
      // unit to provide the real indirection symbol.
      if (isWeak)
        ClassSymbol->setInitializer(new llvm::GlobalVariable(TheModule,
            Int8Ty, false, llvm::GlobalValue::ExternalWeakLinkage,
            nullptr, SymbolForClass(Name)));
      else {
        if (CGM.getTriple().isOSBinFormatCOFF()) {
          IdentifierInfo &II = CGM.getContext().Idents.get(Name);
          TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
          DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
  
          const ObjCInterfaceDecl *OID = nullptr;
          for (const auto &Result : DC->lookup(&II))
            if ((OID = dyn_cast<ObjCInterfaceDecl>(Result)))
              break;
  
          // The first Interface we find may be a @class,
          // which should only be treated as the source of
          // truth in the absence of a true declaration.
          const ObjCInterfaceDecl *OIDDef = OID->getDefinition();
          if (OIDDef != nullptr)
            OID = OIDDef;
  
          auto Storage = llvm::GlobalValue::DefaultStorageClass;
          if (OID->hasAttr<DLLImportAttr>())
            Storage = llvm::GlobalValue::DLLImportStorageClass;
          else if (OID->hasAttr<DLLExportAttr>())
            Storage = llvm::GlobalValue::DLLExportStorageClass;
  
          cast<llvm::GlobalValue>(ClassSymbol)->setDLLStorageClass(Storage);
        }
      }
      assert(ClassSymbol->getName() == SymbolName);
      return ClassSymbol;
    }
    llvm::Value *GetClassNamed(CodeGenFunction &CGF,
                               const std::string &Name,
                               bool isWeak) override {
      return CGF.Builder.CreateLoad(Address(GetClassVar(Name, isWeak),
            CGM.getPointerAlign()));
    }
    int32_t FlagsForOwnership(Qualifiers::ObjCLifetime Ownership) {
      // typedef enum {
      //   ownership_invalid = 0,
      //   ownership_strong  = 1,
      //   ownership_weak    = 2,
      //   ownership_unsafe  = 3
      // } ivar_ownership;
      int Flag;
      switch (Ownership) {
        case Qualifiers::OCL_Strong:
            Flag = 1;
            break;
        case Qualifiers::OCL_Weak:
            Flag = 2;
            break;
        case Qualifiers::OCL_ExplicitNone:
            Flag = 3;
            break;
        case Qualifiers::OCL_None:
        case Qualifiers::OCL_Autoreleasing:
          assert(Ownership != Qualifiers::OCL_Autoreleasing);
          Flag = 0;
      }
      return Flag;
    }
    llvm::Constant *GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames,
                     ArrayRef<llvm::Constant *> IvarTypes,
                     ArrayRef<llvm::Constant *> IvarOffsets,
                     ArrayRef<llvm::Constant *> IvarAlign,
                     ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership) override {
      llvm_unreachable("Method should not be called!");
    }
  
    llvm::Constant *GenerateEmptyProtocol(StringRef ProtocolName) override {
      std::string Name = SymbolForProtocol(ProtocolName);
      auto *GV = TheModule.getGlobalVariable(Name);
      if (!GV) {
        // Emit a placeholder symbol.
        GV = new llvm::GlobalVariable(TheModule, ProtocolTy, false,
            llvm::GlobalValue::ExternalLinkage, nullptr, Name);
        GV->setAlignment(CGM.getPointerAlign().getAsAlign());
      }
      return llvm::ConstantExpr::getBitCast(GV, ProtocolPtrTy);
    }
  
    /// Existing protocol references.
    llvm::StringMap<llvm::Constant*> ExistingProtocolRefs;
  
    llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
                                     const ObjCProtocolDecl *PD) override {
      auto Name = PD->getNameAsString();
      auto *&Ref = ExistingProtocolRefs[Name];
      if (!Ref) {
        auto *&Protocol = ExistingProtocols[Name];
        if (!Protocol)
          Protocol = GenerateProtocolRef(PD);
        std::string RefName = SymbolForProtocolRef(Name);
        assert(!TheModule.getGlobalVariable(RefName));
        // Emit a reference symbol.
        auto GV = new llvm::GlobalVariable(TheModule, ProtocolPtrTy,
            false, llvm::GlobalValue::LinkOnceODRLinkage,
            llvm::ConstantExpr::getBitCast(Protocol, ProtocolPtrTy), RefName);
        GV->setComdat(TheModule.getOrInsertComdat(RefName));
        GV->setSection(sectionName<ProtocolReferenceSection>());
        GV->setAlignment(CGM.getPointerAlign().getAsAlign());
        Ref = GV;
      }
      EmittedProtocolRef = true;
      return CGF.Builder.CreateAlignedLoad(Ref, CGM.getPointerAlign());
    }
  
    llvm::Constant *GenerateProtocolList(ArrayRef<llvm::Constant*> Protocols) {
      llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(ProtocolPtrTy,
          Protocols.size());
      llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,
          Protocols);
      ConstantInitBuilder builder(CGM);
      auto ProtocolBuilder = builder.beginStruct();
      ProtocolBuilder.addNullPointer(PtrTy);
      ProtocolBuilder.addInt(SizeTy, Protocols.size());
      ProtocolBuilder.add(ProtocolArray);
      return ProtocolBuilder.finishAndCreateGlobal(".objc_protocol_list",
          CGM.getPointerAlign(), false, llvm::GlobalValue::InternalLinkage);
    }
  
    void GenerateProtocol(const ObjCProtocolDecl *PD) override {
      // Do nothing - we only emit referenced protocols.
    }
    llvm::Constant *GenerateProtocolRef(const ObjCProtocolDecl *PD) {
      std::string ProtocolName = PD->getNameAsString();
      auto *&Protocol = ExistingProtocols[ProtocolName];
      if (Protocol)
        return Protocol;
  
      EmittedProtocol = true;
  
      auto SymName = SymbolForProtocol(ProtocolName);
      auto *OldGV = TheModule.getGlobalVariable(SymName);
  
      // Use the protocol definition, if there is one.
      if (const ObjCProtocolDecl *Def = PD->getDefinition())
        PD = Def;
      else {
        // If there is no definition, then create an external linkage symbol and
        // hope that someone else fills it in for us (and fail to link if they
        // don't).
        assert(!OldGV);
        Protocol = new llvm::GlobalVariable(TheModule, ProtocolTy,
          /*isConstant*/false,
          llvm::GlobalValue::ExternalLinkage, nullptr, SymName);
        return Protocol;
      }
  
      SmallVector<llvm::Constant*, 16> Protocols;
      for (const auto *PI : PD->protocols())
        Protocols.push_back(
            llvm::ConstantExpr::getBitCast(GenerateProtocolRef(PI),
              ProtocolPtrTy));
      llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);
  
      // Collect information about methods
      llvm::Constant *InstanceMethodList, *OptionalInstanceMethodList;
      llvm::Constant *ClassMethodList, *OptionalClassMethodList;
      EmitProtocolMethodList(PD->instance_methods(), InstanceMethodList,
          OptionalInstanceMethodList);
      EmitProtocolMethodList(PD->class_methods(), ClassMethodList,
          OptionalClassMethodList);
  
      // The isa pointer must be set to a magic number so the runtime knows it's
      // the correct layout.
      ConstantInitBuilder builder(CGM);
      auto ProtocolBuilder = builder.beginStruct();
      ProtocolBuilder.add(llvm::ConstantExpr::getIntToPtr(
            llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
      ProtocolBuilder.add(MakeConstantString(ProtocolName));
      ProtocolBuilder.add(ProtocolList);
      ProtocolBuilder.add(InstanceMethodList);
      ProtocolBuilder.add(ClassMethodList);
      ProtocolBuilder.add(OptionalInstanceMethodList);
      ProtocolBuilder.add(OptionalClassMethodList);
      // Required instance properties
      ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, false, false));
      // Optional instance properties
      ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, false, true));
      // Required class properties
      ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, true, false));
      // Optional class properties
      ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, true, true));
  
      auto *GV = ProtocolBuilder.finishAndCreateGlobal(SymName,
          CGM.getPointerAlign(), false, llvm::GlobalValue::ExternalLinkage);
      GV->setSection(sectionName<ProtocolSection>());
      GV->setComdat(TheModule.getOrInsertComdat(SymName));
      if (OldGV) {
        OldGV->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GV,
              OldGV->getType()));
        OldGV->removeFromParent();
        GV->setName(SymName);
      }
      Protocol = GV;
      return GV;
    }
    llvm::Constant *EnforceType(llvm::Constant *Val, llvm::Type *Ty) {
      if (Val->getType() == Ty)
        return Val;
      return llvm::ConstantExpr::getBitCast(Val, Ty);
    }
    llvm::Value *GetTypedSelector(CodeGenFunction &CGF, Selector Sel,
                                  const std::string &TypeEncoding) override {
      return GetConstantSelector(Sel, TypeEncoding);
    }
    llvm::Constant  *GetTypeString(llvm::StringRef TypeEncoding) {
      if (TypeEncoding.empty())
        return NULLPtr;
      std::string MangledTypes = TypeEncoding;
      std::replace(MangledTypes.begin(), MangledTypes.end(),
        '@', '\1');
      std::string TypesVarName = ".objc_sel_types_" + MangledTypes;
      auto *TypesGlobal = TheModule.getGlobalVariable(TypesVarName);
      if (!TypesGlobal) {
        llvm::Constant *Init = llvm::ConstantDataArray::getString(VMContext,
            TypeEncoding);
        auto *GV = new llvm::GlobalVariable(TheModule, Init->getType(),
            true, llvm::GlobalValue::LinkOnceODRLinkage, Init, TypesVarName);
        GV->setComdat(TheModule.getOrInsertComdat(TypesVarName));
        GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
        TypesGlobal = GV;
      }
      return llvm::ConstantExpr::getGetElementPtr(TypesGlobal->getValueType(),
          TypesGlobal, Zeros);
    }
    llvm::Constant *GetConstantSelector(Selector Sel,
                                        const std::string &TypeEncoding) override {
      // @ is used as a special character in symbol names (used for symbol
      // versioning), so mangle the name to not include it.  Replace it with a
      // character that is not a valid type encoding character (and, being
      // non-printable, never will be!)
      std::string MangledTypes = TypeEncoding;
      std::replace(MangledTypes.begin(), MangledTypes.end(),
        '@', '\1');
      auto SelVarName = (StringRef(".objc_selector_") + Sel.getAsString() + "_" +
        MangledTypes).str();
      if (auto *GV = TheModule.getNamedGlobal(SelVarName))
        return EnforceType(GV, SelectorTy);
      ConstantInitBuilder builder(CGM);
      auto SelBuilder = builder.beginStruct();
      SelBuilder.add(ExportUniqueString(Sel.getAsString(), ".objc_sel_name_",
            true));
      SelBuilder.add(GetTypeString(TypeEncoding));
      auto *GV = SelBuilder.finishAndCreateGlobal(SelVarName,
          CGM.getPointerAlign(), false, llvm::GlobalValue::LinkOnceODRLinkage);
      GV->setComdat(TheModule.getOrInsertComdat(SelVarName));
      GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
      GV->setSection(sectionName<SelectorSection>());
      auto *SelVal = EnforceType(GV, SelectorTy);
      return SelVal;
    }
    llvm::StructType *emptyStruct = nullptr;
  
    /// Return pointers to the start and end of a section.  On ELF platforms, we
    /// use the __start_ and __stop_ symbols that GNU-compatible linkers will set
    /// to the start and end of section names, as long as those section names are
    /// valid identifiers and the symbols are referenced but not defined.  On
    /// Windows, we use the fact that MSVC-compatible linkers will lexically sort
    /// by subsections and place everything that we want to reference in a middle
    /// subsection and then insert zero-sized symbols in subsections a and z.
    std::pair<llvm::Constant*,llvm::Constant*>
    GetSectionBounds(StringRef Section) {
      if (CGM.getTriple().isOSBinFormatCOFF()) {
        if (emptyStruct == nullptr) {
          emptyStruct = llvm::StructType::create(VMContext, ".objc_section_sentinel");
          emptyStruct->setBody({}, /*isPacked*/true);
        }
        auto ZeroInit = llvm::Constant::getNullValue(emptyStruct);
        auto Sym = [&](StringRef Prefix, StringRef SecSuffix) {
          auto *Sym = new llvm::GlobalVariable(TheModule, emptyStruct,
              /*isConstant*/false,
              llvm::GlobalValue::LinkOnceODRLinkage, ZeroInit, Prefix +
              Section);
          Sym->setVisibility(llvm::GlobalValue::HiddenVisibility);
          Sym->setSection((Section + SecSuffix).str());
          Sym->setComdat(TheModule.getOrInsertComdat((Prefix +
              Section).str()));
          Sym->setAlignment(CGM.getPointerAlign().getAsAlign());
          return Sym;
        };
        return { Sym("__start_", "$a"), Sym("__stop", "$z") };
      }
      auto *Start = new llvm::GlobalVariable(TheModule, PtrTy,
          /*isConstant*/false,
          llvm::GlobalValue::ExternalLinkage, nullptr, StringRef("__start_") +
          Section);
      Start->setVisibility(llvm::GlobalValue::HiddenVisibility);
      auto *Stop = new llvm::GlobalVariable(TheModule, PtrTy,
          /*isConstant*/false,
          llvm::GlobalValue::ExternalLinkage, nullptr, StringRef("__stop_") +
          Section);
      Stop->setVisibility(llvm::GlobalValue::HiddenVisibility);
      return { Start, Stop };
    }
    CatchTypeInfo getCatchAllTypeInfo() override {
      return CGM.getCXXABI().getCatchAllTypeInfo();
    }
    llvm::Function *ModuleInitFunction() override {
      llvm::Function *LoadFunction = llvm::Function::Create(
        llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
        llvm::GlobalValue::LinkOnceODRLinkage, ".objcv2_load_function",
        &TheModule);
      LoadFunction->setVisibility(llvm::GlobalValue::HiddenVisibility);
      LoadFunction->setComdat(TheModule.getOrInsertComdat(".objcv2_load_function"));
  
      llvm::BasicBlock *EntryBB =
          llvm::BasicBlock::Create(VMContext, "entry", LoadFunction);
      CGBuilderTy B(CGM, VMContext);
      B.SetInsertPoint(EntryBB);
      ConstantInitBuilder builder(CGM);
      auto InitStructBuilder = builder.beginStruct();
      InitStructBuilder.addInt(Int64Ty, 0);
      auto &sectionVec = CGM.getTriple().isOSBinFormatCOFF() ? PECOFFSectionsBaseNames : SectionsBaseNames;
      for (auto *s : sectionVec) {
        auto bounds = GetSectionBounds(s);
        InitStructBuilder.add(bounds.first);
        InitStructBuilder.add(bounds.second);
      }
      auto *InitStruct = InitStructBuilder.finishAndCreateGlobal(".objc_init",
          CGM.getPointerAlign(), false, llvm::GlobalValue::LinkOnceODRLinkage);
      InitStruct->setVisibility(llvm::GlobalValue::HiddenVisibility);
      InitStruct->setComdat(TheModule.getOrInsertComdat(".objc_init"));
  
      CallRuntimeFunction(B, "__objc_load", {InitStruct});;
      B.CreateRetVoid();
      // Make sure that the optimisers don't delete this function.
      CGM.addCompilerUsedGlobal(LoadFunction);
      // FIXME: Currently ELF only!
      // We have to do this by hand, rather than with @llvm.ctors, so that the
      // linker can remove the duplicate invocations.
      auto *InitVar = new llvm::GlobalVariable(TheModule, LoadFunction->getType(),
          /*isConstant*/true, llvm::GlobalValue::LinkOnceAnyLinkage,
          LoadFunction, ".objc_ctor");
      // Check that this hasn't been renamed.  This shouldn't happen, because
      // this function should be called precisely once.
      assert(InitVar->getName() == ".objc_ctor");
      // In Windows, initialisers are sorted by the suffix.  XCL is for library
      // initialisers, which run before user initialisers.  We are running
      // Objective-C loads at the end of library load.  This means +load methods
      // will run before any other static constructors, but that static
      // constructors can see a fully initialised Objective-C state.
      if (CGM.getTriple().isOSBinFormatCOFF())
          InitVar->setSection(".CRT$XCLz");
      else
      {
        if (CGM.getCodeGenOpts().UseInitArray)
          InitVar->setSection(".init_array");
        else
          InitVar->setSection(".ctors");
      }
      InitVar->setVisibility(llvm::GlobalValue::HiddenVisibility);
      InitVar->setComdat(TheModule.getOrInsertComdat(".objc_ctor"));
      CGM.addUsedGlobal(InitVar);
      for (auto *C : Categories) {
        auto *Cat = cast<llvm::GlobalVariable>(C->stripPointerCasts());
        Cat->setSection(sectionName<CategorySection>());
        CGM.addUsedGlobal(Cat);
      }
      auto createNullGlobal = [&](StringRef Name, ArrayRef<llvm::Constant*> Init,
          StringRef Section) {
        auto nullBuilder = builder.beginStruct();
        for (auto *F : Init)
          nullBuilder.add(F);
        auto GV = nullBuilder.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
            false, llvm::GlobalValue::LinkOnceODRLinkage);
        GV->setSection(Section);
        GV->setComdat(TheModule.getOrInsertComdat(Name));
        GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
        CGM.addUsedGlobal(GV);
        return GV;
      };
      for (auto clsAlias : ClassAliases)
        createNullGlobal(std::string(".objc_class_alias") +
            clsAlias.second, { MakeConstantString(clsAlias.second),
            GetClassVar(clsAlias.first) }, sectionName<ClassAliasSection>());
      // On ELF platforms, add a null value for each special section so that we
      // can always guarantee that the _start and _stop symbols will exist and be
      // meaningful.  This is not required on COFF platforms, where our start and
      // stop symbols will create the section.
      if (!CGM.getTriple().isOSBinFormatCOFF()) {
        createNullGlobal(".objc_null_selector", {NULLPtr, NULLPtr},
            sectionName<SelectorSection>());
        if (Categories.empty())
          createNullGlobal(".objc_null_category", {NULLPtr, NULLPtr,
                        NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr},
              sectionName<CategorySection>());
        if (!EmittedClass) {
          createNullGlobal(".objc_null_cls_init_ref", NULLPtr,
              sectionName<ClassSection>());
          createNullGlobal(".objc_null_class_ref", { NULLPtr, NULLPtr },
              sectionName<ClassReferenceSection>());
        }
        if (!EmittedProtocol)
          createNullGlobal(".objc_null_protocol", {NULLPtr, NULLPtr, NULLPtr,
              NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr,
              NULLPtr}, sectionName<ProtocolSection>());
        if (!EmittedProtocolRef)
          createNullGlobal(".objc_null_protocol_ref", {NULLPtr},
              sectionName<ProtocolReferenceSection>());
        if (ClassAliases.empty())
          createNullGlobal(".objc_null_class_alias", { NULLPtr, NULLPtr },
              sectionName<ClassAliasSection>());
        if (ConstantStrings.empty()) {
          auto i32Zero = llvm::ConstantInt::get(Int32Ty, 0);
          createNullGlobal(".objc_null_constant_string", { NULLPtr, i32Zero,
              i32Zero, i32Zero, i32Zero, NULLPtr },
              sectionName<ConstantStringSection>());
        }
      }
      ConstantStrings.clear();
      Categories.clear();
      Classes.clear();
  
      if (EarlyInitList.size() > 0) {
        auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.VoidTy,
              {}), llvm::GlobalValue::InternalLinkage, ".objc_early_init",
            &CGM.getModule());
        llvm::IRBuilder<> b(llvm::BasicBlock::Create(CGM.getLLVMContext(), "entry",
              Init));
        for (const auto &lateInit : EarlyInitList) {
          auto *global = TheModule.getGlobalVariable(lateInit.first);
          if (global) {
            b.CreateAlignedStore(global,
                b.CreateStructGEP(lateInit.second.first, lateInit.second.second), CGM.getPointerAlign().getQuantity());
          }
        }
        b.CreateRetVoid();
        // We can't use the normal LLVM global initialisation array, because we
        // need to specify that this runs early in library initialisation.
        auto *InitVar = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), 
            /*isConstant*/true, llvm::GlobalValue::InternalLinkage,
            Init, ".objc_early_init_ptr");
        InitVar->setSection(".CRT$XCLb");
        CGM.addUsedGlobal(InitVar);
      }
      return nullptr;
    }
    /// In the v2 ABI, ivar offset variables use the type encoding in their name
    /// to trigger linker failures if the types don't match.
    std::string GetIVarOffsetVariableName(const ObjCInterfaceDecl *ID,
                                          const ObjCIvarDecl *Ivar) override {
      std::string TypeEncoding;
      CGM.getContext().getObjCEncodingForType(Ivar->getType(), TypeEncoding);
      // Prevent the @ from being interpreted as a symbol version.
      std::replace(TypeEncoding.begin(), TypeEncoding.end(),
        '@', '\1');
      const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString()
        + '.' + Ivar->getNameAsString() + '.' + TypeEncoding;
      return Name;
    }
    llvm::Value *EmitIvarOffset(CodeGenFunction &CGF,
                                const ObjCInterfaceDecl *Interface,
                                const ObjCIvarDecl *Ivar) override {
      const std::string Name = GetIVarOffsetVariableName(Ivar->getContainingInterface(), Ivar);
      llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name);
      if (!IvarOffsetPointer)
        IvarOffsetPointer = new llvm::GlobalVariable(TheModule, IntTy, false,
                llvm::GlobalValue::ExternalLinkage, nullptr, Name);
      CharUnits Align = CGM.getIntAlign();
      llvm::Value *Offset = CGF.Builder.CreateAlignedLoad(IvarOffsetPointer, Align);
      if (Offset->getType() != PtrDiffTy)
        Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy);
      return Offset;
    }
    void GenerateClass(const ObjCImplementationDecl *OID) override {
      ASTContext &Context = CGM.getContext();
      bool IsCOFF = CGM.getTriple().isOSBinFormatCOFF();
  
      // Get the class name
      ObjCInterfaceDecl *classDecl =
          const_cast<ObjCInterfaceDecl *>(OID->getClassInterface());
      std::string className = classDecl->getNameAsString();
      auto *classNameConstant = MakeConstantString(className);
  
      ConstantInitBuilder builder(CGM);
      auto metaclassFields = builder.beginStruct();
      // struct objc_class *isa;
      metaclassFields.addNullPointer(PtrTy);
      // struct objc_class *super_class;
      metaclassFields.addNullPointer(PtrTy);
      // const char *name;
      metaclassFields.add(classNameConstant);
      // long version;
      metaclassFields.addInt(LongTy, 0);
      // unsigned long info;
      // objc_class_flag_meta
      metaclassFields.addInt(LongTy, 1);
      // long instance_size;
      // Setting this to zero is consistent with the older ABI, but it might be
      // more sensible to set this to sizeof(struct objc_class)
      metaclassFields.addInt(LongTy, 0);
      // struct objc_ivar_list *ivars;
      metaclassFields.addNullPointer(PtrTy);
      // struct objc_method_list *methods
      // FIXME: Almost identical code is copied and pasted below for the
      // class, but refactoring it cleanly requires C++14 generic lambdas.
      if (OID->classmeth_begin() == OID->classmeth_end())
        metaclassFields.addNullPointer(PtrTy);
      else {
        SmallVector<ObjCMethodDecl*, 16> ClassMethods;
        ClassMethods.insert(ClassMethods.begin(), OID->classmeth_begin(),
            OID->classmeth_end());
        metaclassFields.addBitCast(
                GenerateMethodList(className, "", ClassMethods, true),
                PtrTy);
      }
      // void *dtable;
      metaclassFields.addNullPointer(PtrTy);
      // IMP cxx_construct;
      metaclassFields.addNullPointer(PtrTy);
      // IMP cxx_destruct;
      metaclassFields.addNullPointer(PtrTy);
      // struct objc_class *subclass_list
      metaclassFields.addNullPointer(PtrTy);
      // struct objc_class *sibling_class
      metaclassFields.addNullPointer(PtrTy);
      // struct objc_protocol_list *protocols;
      metaclassFields.addNullPointer(PtrTy);
      // struct reference_list *extra_data;
      metaclassFields.addNullPointer(PtrTy);
      // long abi_version;
      metaclassFields.addInt(LongTy, 0);
      // struct objc_property_list *properties
      metaclassFields.add(GeneratePropertyList(OID, classDecl, /*isClassProperty*/true));
  
      auto *metaclass = metaclassFields.finishAndCreateGlobal(
          ManglePublicSymbol("OBJC_METACLASS_") + className,
          CGM.getPointerAlign());
  
      auto classFields = builder.beginStruct();
      // struct objc_class *isa;
      classFields.add(metaclass);
      // struct objc_class *super_class;
      // Get the superclass name.
      const ObjCInterfaceDecl * SuperClassDecl =
        OID->getClassInterface()->getSuperClass();
      llvm::Constant *SuperClass = nullptr;
      if (SuperClassDecl) {
        auto SuperClassName = SymbolForClass(SuperClassDecl->getNameAsString());
        SuperClass = TheModule.getNamedGlobal(SuperClassName);
        if (!SuperClass)
        {
          SuperClass = new llvm::GlobalVariable(TheModule, PtrTy, false,
              llvm::GlobalValue::ExternalLinkage, nullptr, SuperClassName);
          if (IsCOFF) {
            auto Storage = llvm::GlobalValue::DefaultStorageClass;
            if (SuperClassDecl->hasAttr<DLLImportAttr>())
              Storage = llvm::GlobalValue::DLLImportStorageClass;
            else if (SuperClassDecl->hasAttr<DLLExportAttr>())
              Storage = llvm::GlobalValue::DLLExportStorageClass;
  
            cast<llvm::GlobalValue>(SuperClass)->setDLLStorageClass(Storage);
          }
        }
        if (!IsCOFF)
          classFields.add(llvm::ConstantExpr::getBitCast(SuperClass, PtrTy));
        else
          classFields.addNullPointer(PtrTy);
      } else
        classFields.addNullPointer(PtrTy);
      // const char *name;
      classFields.add(classNameConstant);
      // long version;
      classFields.addInt(LongTy, 0);
      // unsigned long info;
      // !objc_class_flag_meta
      classFields.addInt(LongTy, 0);
      // long instance_size;
      int superInstanceSize = !SuperClassDecl ? 0 :
        Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize().getQuantity();
      // Instance size is negative for classes that have not yet had their ivar
      // layout calculated.
      classFields.addInt(LongTy,
        0 - (Context.getASTObjCImplementationLayout(OID).getSize().getQuantity() -
        superInstanceSize));
  
      if (classDecl->all_declared_ivar_begin() == nullptr)
        classFields.addNullPointer(PtrTy);
      else {
        int ivar_count = 0;
        for (const ObjCIvarDecl *IVD = classDecl->all_declared_ivar_begin(); IVD;
             IVD = IVD->getNextIvar()) ivar_count++;
        llvm::DataLayout td(&TheModule);
        // struct objc_ivar_list *ivars;
        ConstantInitBuilder b(CGM);
        auto ivarListBuilder = b.beginStruct();
        // int count;
        ivarListBuilder.addInt(IntTy, ivar_count);
        // size_t size;
        llvm::StructType *ObjCIvarTy = llvm::StructType::get(
          PtrToInt8Ty,
          PtrToInt8Ty,
          PtrToInt8Ty,
          Int32Ty,
          Int32Ty);
        ivarListBuilder.addInt(SizeTy, td.getTypeSizeInBits(ObjCIvarTy) /
            CGM.getContext().getCharWidth());
        // struct objc_ivar ivars[]
        auto ivarArrayBuilder = ivarListBuilder.beginArray();
        for (const ObjCIvarDecl *IVD = classDecl->all_declared_ivar_begin(); IVD;
             IVD = IVD->getNextIvar()) {
          auto ivarTy = IVD->getType();
          auto ivarBuilder = ivarArrayBuilder.beginStruct();
          // const char *name;
          ivarBuilder.add(MakeConstantString(IVD->getNameAsString()));
          // const char *type;
          std::string TypeStr;
          //Context.getObjCEncodingForType(ivarTy, TypeStr, IVD, true);
          Context.getObjCEncodingForMethodParameter(Decl::OBJC_TQ_None, ivarTy, TypeStr, true);
          ivarBuilder.add(MakeConstantString(TypeStr));
          // int *offset;
          uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD);
          uint64_t Offset = BaseOffset - superInstanceSize;
          llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset);
          std::string OffsetName = GetIVarOffsetVariableName(classDecl, IVD);
          llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName);
          if (OffsetVar)
            OffsetVar->setInitializer(OffsetValue);
          else
            OffsetVar = new llvm::GlobalVariable(TheModule, IntTy,
              false, llvm::GlobalValue::ExternalLinkage,
              OffsetValue, OffsetName);
          auto ivarVisibility =
              (IVD->getAccessControl() == ObjCIvarDecl::Private ||
               IVD->getAccessControl() == ObjCIvarDecl::Package ||
               classDecl->getVisibility() == HiddenVisibility) ?
                      llvm::GlobalValue::HiddenVisibility :
                      llvm::GlobalValue::DefaultVisibility;
          OffsetVar->setVisibility(ivarVisibility);
          ivarBuilder.add(OffsetVar);
          // Ivar size
          ivarBuilder.addInt(Int32Ty,
              CGM.getContext().getTypeSizeInChars(ivarTy).getQuantity());
          // Alignment will be stored as a base-2 log of the alignment.
          unsigned align =
              llvm::Log2_32(Context.getTypeAlignInChars(ivarTy).getQuantity());
          // Objects that require more than 2^64-byte alignment should be impossible!
          assert(align < 64);
          // uint32_t flags;
          // Bits 0-1 are ownership.
          // Bit 2 indicates an extended type encoding
          // Bits 3-8 contain log2(aligment)
          ivarBuilder.addInt(Int32Ty,
              (align << 3) | (1<<2) |
              FlagsForOwnership(ivarTy.getQualifiers().getObjCLifetime()));
          ivarBuilder.finishAndAddTo(ivarArrayBuilder);
        }
        ivarArrayBuilder.finishAndAddTo(ivarListBuilder);
        auto ivarList = ivarListBuilder.finishAndCreateGlobal(".objc_ivar_list",
            CGM.getPointerAlign(), /*constant*/ false,
            llvm::GlobalValue::PrivateLinkage);
        classFields.add(ivarList);
      }
      // struct objc_method_list *methods
      SmallVector<const ObjCMethodDecl*, 16> InstanceMethods;
      InstanceMethods.insert(InstanceMethods.begin(), OID->instmeth_begin(),
          OID->instmeth_end());
      for (auto *propImpl : OID->property_impls())
        if (propImpl->getPropertyImplementation() ==
            ObjCPropertyImplDecl::Synthesize) {
          ObjCPropertyDecl *prop = propImpl->getPropertyDecl();
          auto addIfExists = [&](const ObjCMethodDecl* OMD) {
            if (OMD)
              InstanceMethods.push_back(OMD);
          };
          addIfExists(prop->getGetterMethodDecl());
          addIfExists(prop->getSetterMethodDecl());
        }
  
      if (InstanceMethods.size() == 0)
        classFields.addNullPointer(PtrTy);
      else
        classFields.addBitCast(
                GenerateMethodList(className, "", InstanceMethods, false),
                PtrTy);
      // void *dtable;
      classFields.addNullPointer(PtrTy);
      // IMP cxx_construct;
      classFields.addNullPointer(PtrTy);
      // IMP cxx_destruct;
      classFields.addNullPointer(PtrTy);
      // struct objc_class *subclass_list
      classFields.addNullPointer(PtrTy);
      // struct objc_class *sibling_class
      classFields.addNullPointer(PtrTy);
      // struct objc_protocol_list *protocols;
      SmallVector<llvm::Constant*, 16> Protocols;
      for (const auto *I : classDecl->protocols())
        Protocols.push_back(
            llvm::ConstantExpr::getBitCast(GenerateProtocolRef(I),
              ProtocolPtrTy));
      if (Protocols.empty())
        classFields.addNullPointer(PtrTy);
      else
        classFields.add(GenerateProtocolList(Protocols));
      // struct reference_list *extra_data;
      classFields.addNullPointer(PtrTy);
      // long abi_version;
      classFields.addInt(LongTy, 0);
      // struct objc_property_list *properties
      classFields.add(GeneratePropertyList(OID, classDecl));
  
      auto *classStruct =
        classFields.finishAndCreateGlobal(SymbolForClass(className),
          CGM.getPointerAlign(), false, llvm::GlobalValue::ExternalLinkage);
  
      auto *classRefSymbol = GetClassVar(className);
      classRefSymbol->setSection(sectionName<ClassReferenceSection>());
      classRefSymbol->setInitializer(llvm::ConstantExpr::getBitCast(classStruct, IdTy));
  
      if (IsCOFF) {
        // we can't import a class struct.
        if (OID->getClassInterface()->hasAttr<DLLExportAttr>()) {
          cast<llvm::GlobalValue>(classStruct)->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
          cast<llvm::GlobalValue>(classRefSymbol)->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
        }
  
        if (SuperClass) {
          std::pair<llvm::Constant*, int> v{classStruct, 1};
          EarlyInitList.emplace_back(SuperClass->getName(), std::move(v));
        }
  
      }
  
  
      // Resolve the class aliases, if they exist.
      // FIXME: Class pointer aliases shouldn't exist!
      if (ClassPtrAlias) {
        ClassPtrAlias->replaceAllUsesWith(
            llvm::ConstantExpr::getBitCast(classStruct, IdTy));
        ClassPtrAlias->eraseFromParent();
        ClassPtrAlias = nullptr;
      }
      if (auto Placeholder =
          TheModule.getNamedGlobal(SymbolForClass(className)))
        if (Placeholder != classStruct) {
          Placeholder->replaceAllUsesWith(
              llvm::ConstantExpr::getBitCast(classStruct, Placeholder->getType()));
          Placeholder->eraseFromParent();
          classStruct->setName(SymbolForClass(className));
        }
      if (MetaClassPtrAlias) {
        MetaClassPtrAlias->replaceAllUsesWith(
            llvm::ConstantExpr::getBitCast(metaclass, IdTy));
        MetaClassPtrAlias->eraseFromParent();
        MetaClassPtrAlias = nullptr;
      }
      assert(classStruct->getName() == SymbolForClass(className));
  
      auto classInitRef = new llvm::GlobalVariable(TheModule,
          classStruct->getType(), false, llvm::GlobalValue::ExternalLinkage,
          classStruct, ManglePublicSymbol("OBJC_INIT_CLASS_") + className);
      classInitRef->setSection(sectionName<ClassSection>());
      CGM.addUsedGlobal(classInitRef);
  
      EmittedClass = true;
    }
    public:
      CGObjCGNUstep2(CodeGenModule &Mod) : CGObjCGNUstep(Mod, 10, 4, 2) {
        MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
                              PtrToObjCSuperTy, SelectorTy);
        // struct objc_property
        // {
        //   const char *name;
        //   const char *attributes;
        //   const char *type;
        //   SEL getter;
        //   SEL setter;
        // }
        PropertyMetadataTy =
          llvm::StructType::get(CGM.getLLVMContext(),
              { PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty });
      }
  
  };
  
  const char *const CGObjCGNUstep2::SectionsBaseNames[8] =
  {
  "__objc_selectors",
  "__objc_classes",
  "__objc_class_refs",
  "__objc_cats",
  "__objc_protocols",
  "__objc_protocol_refs",
  "__objc_class_aliases",
  "__objc_constant_string"
  };
  
  const char *const CGObjCGNUstep2::PECOFFSectionsBaseNames[8] =
  {
  ".objcrt$SEL",
  ".objcrt$CLS",
  ".objcrt$CLR",
  ".objcrt$CAT",
  ".objcrt$PCL",
  ".objcrt$PCR",
  ".objcrt$CAL",
  ".objcrt$STR"
  };
  
  /// Support for the ObjFW runtime.
  class CGObjCObjFW: public CGObjCGNU {
  protected:
    /// The GCC ABI message lookup function.  Returns an IMP pointing to the
    /// method implementation for this message.
    LazyRuntimeFunction MsgLookupFn;
    /// stret lookup function.  While this does not seem to make sense at the
    /// first look, this is required to call the correct forwarding function.
    LazyRuntimeFunction MsgLookupFnSRet;
    /// The GCC ABI superclass message lookup function.  Takes a pointer to a
    /// structure describing the receiver and the class, and a selector as
    /// arguments.  Returns the IMP for the corresponding method.
    LazyRuntimeFunction MsgLookupSuperFn, MsgLookupSuperFnSRet;
  
    llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver,
                           llvm::Value *cmd, llvm::MDNode *node,
                           MessageSendInfo &MSI) override {
      CGBuilderTy &Builder = CGF.Builder;
      llvm::Value *args[] = {
              EnforceType(Builder, Receiver, IdTy),
              EnforceType(Builder, cmd, SelectorTy) };
  
      llvm::CallBase *imp;
      if (CGM.ReturnTypeUsesSRet(MSI.CallInfo))
        imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFnSRet, args);
      else
        imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFn, args);
  
      imp->setMetadata(msgSendMDKind, node);
      return imp;
    }
  
    llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
                                llvm::Value *cmd, MessageSendInfo &MSI) override {
      CGBuilderTy &Builder = CGF.Builder;
      llvm::Value *lookupArgs[] = {
          EnforceType(Builder, ObjCSuper.getPointer(), PtrToObjCSuperTy), cmd,
      };
  
      if (CGM.ReturnTypeUsesSRet(MSI.CallInfo))
        return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFnSRet, lookupArgs);
      else
        return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs);
    }
  
    llvm::Value *GetClassNamed(CodeGenFunction &CGF, const std::string &Name,
                               bool isWeak) override {
      if (isWeak)
        return CGObjCGNU::GetClassNamed(CGF, Name, isWeak);
  
      EmitClassRef(Name);
      std::string SymbolName = "_OBJC_CLASS_" + Name;
      llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(SymbolName);
      if (!ClassSymbol)
        ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false,
                                               llvm::GlobalValue::ExternalLinkage,
                                               nullptr, SymbolName);
      return ClassSymbol;
    }
  
  public:
    CGObjCObjFW(CodeGenModule &Mod): CGObjCGNU(Mod, 9, 3) {
      // IMP objc_msg_lookup(id, SEL);
      MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy);
      MsgLookupFnSRet.init(&CGM, "objc_msg_lookup_stret", IMPTy, IdTy,
                           SelectorTy);
      // IMP objc_msg_lookup_super(struct objc_super*, SEL);
      MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
                            PtrToObjCSuperTy, SelectorTy);
      MsgLookupSuperFnSRet.init(&CGM, "objc_msg_lookup_super_stret", IMPTy,
                                PtrToObjCSuperTy, SelectorTy);
    }
  };
  } // end anonymous namespace
  
  /// Emits a reference to a dummy variable which is emitted with each class.
  /// This ensures that a linker error will be generated when trying to link
  /// together modules where a referenced class is not defined.
  void CGObjCGNU::EmitClassRef(const std::string &className) {
    std::string symbolRef = "__objc_class_ref_" + className;
    // Don't emit two copies of the same symbol
    if (TheModule.getGlobalVariable(symbolRef))
      return;
    std::string symbolName = "__objc_class_name_" + className;
    llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(symbolName);
    if (!ClassSymbol) {
      ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false,
                                             llvm::GlobalValue::ExternalLinkage,
                                             nullptr, symbolName);
    }
    new llvm::GlobalVariable(TheModule, ClassSymbol->getType(), true,
      llvm::GlobalValue::WeakAnyLinkage, ClassSymbol, symbolRef);
  }
  
  CGObjCGNU::CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion,
                       unsigned protocolClassVersion, unsigned classABI)
    : CGObjCRuntime(cgm), TheModule(CGM.getModule()),
      VMContext(cgm.getLLVMContext()), ClassPtrAlias(nullptr),
      MetaClassPtrAlias(nullptr), RuntimeVersion(runtimeABIVersion),
      ProtocolVersion(protocolClassVersion), ClassABIVersion(classABI) {
  
    msgSendMDKind = VMContext.getMDKindID("GNUObjCMessageSend");
    usesSEHExceptions =
        cgm.getContext().getTargetInfo().getTriple().isWindowsMSVCEnvironment();
  
    CodeGenTypes &Types = CGM.getTypes();
    IntTy = cast<llvm::IntegerType>(
        Types.ConvertType(CGM.getContext().IntTy));
    LongTy = cast<llvm::IntegerType>(
        Types.ConvertType(CGM.getContext().LongTy));
    SizeTy = cast<llvm::IntegerType>(
        Types.ConvertType(CGM.getContext().getSizeType()));
    PtrDiffTy = cast<llvm::IntegerType>(
        Types.ConvertType(CGM.getContext().getPointerDiffType()));
    BoolTy = CGM.getTypes().ConvertType(CGM.getContext().BoolTy);
  
    Int8Ty = llvm::Type::getInt8Ty(VMContext);
    // C string type.  Used in lots of places.
    PtrToInt8Ty = llvm::PointerType::getUnqual(Int8Ty);
    ProtocolPtrTy = llvm::PointerType::getUnqual(
        Types.ConvertType(CGM.getContext().getObjCProtoType()));
  
    Zeros[0] = llvm::ConstantInt::get(LongTy, 0);
    Zeros[1] = Zeros[0];
    NULLPtr = llvm::ConstantPointerNull::get(PtrToInt8Ty);
    // Get the selector Type.
    QualType selTy = CGM.getContext().getObjCSelType();
    if (QualType() == selTy) {
      SelectorTy = PtrToInt8Ty;
    } else {
      SelectorTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(selTy));
    }
  
    PtrToIntTy = llvm::PointerType::getUnqual(IntTy);
    PtrTy = PtrToInt8Ty;
  
    Int32Ty = llvm::Type::getInt32Ty(VMContext);
    Int64Ty = llvm::Type::getInt64Ty(VMContext);
  
    IntPtrTy =
        CGM.getDataLayout().getPointerSizeInBits() == 32 ? Int32Ty : Int64Ty;
  
    // Object type
    QualType UnqualIdTy = CGM.getContext().getObjCIdType();
    ASTIdTy = CanQualType();
    if (UnqualIdTy != QualType()) {
      ASTIdTy = CGM.getContext().getCanonicalType(UnqualIdTy);
      IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
    } else {
      IdTy = PtrToInt8Ty;
    }
    PtrToIdTy = llvm::PointerType::getUnqual(IdTy);
    ProtocolTy = llvm::StructType::get(IdTy,
        PtrToInt8Ty, // name
        PtrToInt8Ty, // protocols
        PtrToInt8Ty, // instance methods
        PtrToInt8Ty, // class methods
        PtrToInt8Ty, // optional instance methods
        PtrToInt8Ty, // optional class methods
        PtrToInt8Ty, // properties
        PtrToInt8Ty);// optional properties
  
    // struct objc_property_gsv1
    // {
    //   const char *name;
    //   char attributes;
    //   char attributes2;
    //   char unused1;
    //   char unused2;
    //   const char *getter_name;
    //   const char *getter_types;
    //   const char *setter_name;
    //   const char *setter_types;
    // }
    PropertyMetadataTy = llvm::StructType::get(CGM.getLLVMContext(), {
        PtrToInt8Ty, Int8Ty, Int8Ty, Int8Ty, Int8Ty, PtrToInt8Ty, PtrToInt8Ty,
        PtrToInt8Ty, PtrToInt8Ty });
  
    ObjCSuperTy = llvm::StructType::get(IdTy, IdTy);
    PtrToObjCSuperTy = llvm::PointerType::getUnqual(ObjCSuperTy);
  
    llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
  
    // void objc_exception_throw(id);
    ExceptionThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy);
    ExceptionReThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy);
    // int objc_sync_enter(id);
    SyncEnterFn.init(&CGM, "objc_sync_enter", IntTy, IdTy);
    // int objc_sync_exit(id);
    SyncExitFn.init(&CGM, "objc_sync_exit", IntTy, IdTy);
  
    // void objc_enumerationMutation (id)
    EnumerationMutationFn.init(&CGM, "objc_enumerationMutation", VoidTy, IdTy);
  
    // id objc_getProperty(id, SEL, ptrdiff_t, BOOL)
    GetPropertyFn.init(&CGM, "objc_getProperty", IdTy, IdTy, SelectorTy,
                       PtrDiffTy, BoolTy);
    // void objc_setProperty(id, SEL, ptrdiff_t, id, BOOL, BOOL)
    SetPropertyFn.init(&CGM, "objc_setProperty", VoidTy, IdTy, SelectorTy,
                       PtrDiffTy, IdTy, BoolTy, BoolTy);
    // void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL)
    GetStructPropertyFn.init(&CGM, "objc_getPropertyStruct", VoidTy, PtrTy, PtrTy,
                             PtrDiffTy, BoolTy, BoolTy);
    // void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL)
    SetStructPropertyFn.init(&CGM, "objc_setPropertyStruct", VoidTy, PtrTy, PtrTy,
                             PtrDiffTy, BoolTy, BoolTy);
  
    // IMP type
    llvm::Type *IMPArgs[] = { IdTy, SelectorTy };
    IMPTy = llvm::PointerType::getUnqual(llvm::FunctionType::get(IdTy, IMPArgs,
                true));
  
    const LangOptions &Opts = CGM.getLangOpts();
    if ((Opts.getGC() != LangOptions::NonGC) || Opts.ObjCAutoRefCount)
      RuntimeVersion = 10;
  
    // Don't bother initialising the GC stuff unless we're compiling in GC mode
    if (Opts.getGC() != LangOptions::NonGC) {
      // This is a bit of an hack.  We should sort this out by having a proper
      // CGObjCGNUstep subclass for GC, but we may want to really support the old
      // ABI and GC added in ObjectiveC2.framework, so we fudge it a bit for now
      // Get selectors needed in GC mode
      RetainSel = GetNullarySelector("retain", CGM.getContext());
      ReleaseSel = GetNullarySelector("release", CGM.getContext());
      AutoreleaseSel = GetNullarySelector("autorelease", CGM.getContext());
  
      // Get functions needed in GC mode
  
      // id objc_assign_ivar(id, id, ptrdiff_t);
      IvarAssignFn.init(&CGM, "objc_assign_ivar", IdTy, IdTy, IdTy, PtrDiffTy);
      // id objc_assign_strongCast (id, id*)
      StrongCastAssignFn.init(&CGM, "objc_assign_strongCast", IdTy, IdTy,
                              PtrToIdTy);
      // id objc_assign_global(id, id*);
      GlobalAssignFn.init(&CGM, "objc_assign_global", IdTy, IdTy, PtrToIdTy);
      // id objc_assign_weak(id, id*);
      WeakAssignFn.init(&CGM, "objc_assign_weak", IdTy, IdTy, PtrToIdTy);
      // id objc_read_weak(id*);
      WeakReadFn.init(&CGM, "objc_read_weak", IdTy, PtrToIdTy);
      // void *objc_memmove_collectable(void*, void *, size_t);
      MemMoveFn.init(&CGM, "objc_memmove_collectable", PtrTy, PtrTy, PtrTy,
                     SizeTy);
    }
  }
  
  llvm::Value *CGObjCGNU::GetClassNamed(CodeGenFunction &CGF,
                                        const std::string &Name, bool isWeak) {
    llvm::Constant *ClassName = MakeConstantString(Name);
    // With the incompatible ABI, this will need to be replaced with a direct
    // reference to the class symbol.  For the compatible nonfragile ABI we are
    // still performing this lookup at run time but emitting the symbol for the
    // class externally so that we can make the switch later.
    //
    // Libobjc2 contains an LLVM pass that replaces calls to objc_lookup_class
    // with memoized versions or with static references if it's safe to do so.
    if (!isWeak)
      EmitClassRef(Name);
  
    llvm::FunctionCallee ClassLookupFn = CGM.CreateRuntimeFunction(
        llvm::FunctionType::get(IdTy, PtrToInt8Ty, true), "objc_lookup_class");
    return CGF.EmitNounwindRuntimeCall(ClassLookupFn, ClassName);
  }
  
  // This has to perform the lookup every time, since posing and related
  // techniques can modify the name -> class mapping.
  llvm::Value *CGObjCGNU::GetClass(CodeGenFunction &CGF,
                                   const ObjCInterfaceDecl *OID) {
    auto *Value =
        GetClassNamed(CGF, OID->getNameAsString(), OID->isWeakImported());
    if (auto *ClassSymbol = dyn_cast<llvm::GlobalVariable>(Value))
      CGM.setGVProperties(ClassSymbol, OID);
    return Value;
  }
  
  llvm::Value *CGObjCGNU::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
    auto *Value  = GetClassNamed(CGF, "NSAutoreleasePool", false);
    if (CGM.getTriple().isOSBinFormatCOFF()) {
      if (auto *ClassSymbol = dyn_cast<llvm::GlobalVariable>(Value)) {
        IdentifierInfo &II = CGF.CGM.getContext().Idents.get("NSAutoreleasePool");
        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;
  
        CGM.setGVProperties(ClassSymbol, VD);
      }
    }
    return Value;
  }
  
  llvm::Value *CGObjCGNU::GetTypedSelector(CodeGenFunction &CGF, Selector Sel,
                                           const std::string &TypeEncoding) {
    SmallVectorImpl<TypedSelector> &Types = SelectorTable[Sel];
    llvm::GlobalAlias *SelValue = nullptr;
  
    for (SmallVectorImpl<TypedSelector>::iterator i = Types.begin(),
        e = Types.end() ; i!=e ; i++) {
      if (i->first == TypeEncoding) {
        SelValue = i->second;
        break;
      }
    }
    if (!SelValue) {
      SelValue = llvm::GlobalAlias::create(
          SelectorTy->getElementType(), 0, llvm::GlobalValue::PrivateLinkage,
          ".objc_selector_" + Sel.getAsString(), &TheModule);
      Types.emplace_back(TypeEncoding, SelValue);
    }
  
    return SelValue;
  }
  
  Address CGObjCGNU::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
    llvm::Value *SelValue = GetSelector(CGF, Sel);
  
    // Store it to a temporary.  Does this satisfy the semantics of
    // GetAddrOfSelector?  Hopefully.
    Address tmp = CGF.CreateTempAlloca(SelValue->getType(),
                                       CGF.getPointerAlign());
    CGF.Builder.CreateStore(SelValue, tmp);
    return tmp;
  }
  
  llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF, Selector Sel) {
    return GetTypedSelector(CGF, Sel, std::string());
  }
  
  llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF,
                                      const ObjCMethodDecl *Method) {
    std::string SelTypes = CGM.getContext().getObjCEncodingForMethodDecl(Method);
    return GetTypedSelector(CGF, Method->getSelector(), SelTypes);
  }
  
  llvm::Constant *CGObjCGNU::GetEHType(QualType T) {
    if (T->isObjCIdType() || T->isObjCQualifiedIdType()) {
      // With the old ABI, there was only one kind of catchall, which broke
      // foreign exceptions.  With the new ABI, we use __objc_id_typeinfo as
      // a pointer indicating object catchalls, and NULL to indicate real
      // catchalls
      if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
        return MakeConstantString("@id");
      } else {
        return nullptr;
      }
    }
  
    // All other types should be Objective-C interface pointer types.
    const ObjCObjectPointerType *OPT = T->getAs<ObjCObjectPointerType>();
    assert(OPT && "Invalid @catch type.");
    const ObjCInterfaceDecl *IDecl = OPT->getObjectType()->getInterface();
    assert(IDecl && "Invalid @catch type.");
    return MakeConstantString(IDecl->getIdentifier()->getName());
  }
  
  llvm::Constant *CGObjCGNUstep::GetEHType(QualType T) {
    if (usesSEHExceptions)
      return CGM.getCXXABI().getAddrOfRTTIDescriptor(T);
  
    if (!CGM.getLangOpts().CPlusPlus)
      return CGObjCGNU::GetEHType(T);
  
    // For Objective-C++, we want to provide the ability to catch both C++ and
    // Objective-C objects in the same function.
  
    // There's a particular fixed type info for 'id'.
    if (T->isObjCIdType() ||
        T->isObjCQualifiedIdType()) {
      llvm::Constant *IDEHType =
        CGM.getModule().getGlobalVariable("__objc_id_type_info");
      if (!IDEHType)
        IDEHType =
          new llvm::GlobalVariable(CGM.getModule(), PtrToInt8Ty,
                                   false,
                                   llvm::GlobalValue::ExternalLinkage,
                                   nullptr, "__objc_id_type_info");
      return llvm::ConstantExpr::getBitCast(IDEHType, PtrToInt8Ty);
    }
  
    const ObjCObjectPointerType *PT =
      T->getAs<ObjCObjectPointerType>();
    assert(PT && "Invalid @catch type.");
    const ObjCInterfaceType *IT = PT->getInterfaceType();
    assert(IT && "Invalid @catch type.");
    std::string className = IT->getDecl()->getIdentifier()->getName();
  
    std::string typeinfoName = "__objc_eh_typeinfo_" + className;
  
    // Return the existing typeinfo if it exists
    llvm::Constant *typeinfo = TheModule.getGlobalVariable(typeinfoName);
    if (typeinfo)
      return llvm::ConstantExpr::getBitCast(typeinfo, PtrToInt8Ty);
  
    // Otherwise create it.
  
    // vtable for gnustep::libobjc::__objc_class_type_info
    // It's quite ugly hard-coding this.  Ideally we'd generate it using the host
    // platform's name mangling.
    const char *vtableName = "_ZTVN7gnustep7libobjc22__objc_class_type_infoE";
    auto *Vtable = TheModule.getGlobalVariable(vtableName);
    if (!Vtable) {
      Vtable = new llvm::GlobalVariable(TheModule, PtrToInt8Ty, true,
                                        llvm::GlobalValue::ExternalLinkage,
                                        nullptr, vtableName);
    }
    llvm::Constant *Two = llvm::ConstantInt::get(IntTy, 2);
    auto *BVtable = llvm::ConstantExpr::getBitCast(
        llvm::ConstantExpr::getGetElementPtr(Vtable->getValueType(), Vtable, Two),
        PtrToInt8Ty);
  
    llvm::Constant *typeName =
      ExportUniqueString(className, "__objc_eh_typename_");
  
    ConstantInitBuilder builder(CGM);
    auto fields = builder.beginStruct();
    fields.add(BVtable);
    fields.add(typeName);
    llvm::Constant *TI =
      fields.finishAndCreateGlobal("__objc_eh_typeinfo_" + className,
                                   CGM.getPointerAlign(),
                                   /*constant*/ false,
                                   llvm::GlobalValue::LinkOnceODRLinkage);
    return llvm::ConstantExpr::getBitCast(TI, PtrToInt8Ty);
  }
  
  /// Generate an NSConstantString object.
  ConstantAddress CGObjCGNU::GenerateConstantString(const StringLiteral *SL) {
  
    std::string Str = SL->getString().str();
    CharUnits Align = CGM.getPointerAlign();
  
    // Look for an existing one
    llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str);
    if (old != ObjCStrings.end())
      return ConstantAddress(old->getValue(), Align);
  
    StringRef StringClass = CGM.getLangOpts().ObjCConstantStringClass;
  
    if (StringClass.empty()) StringClass = "NSConstantString";
  
    std::string Sym = "_OBJC_CLASS_";
    Sym += StringClass;
  
    llvm::Constant *isa = TheModule.getNamedGlobal(Sym);
  
    if (!isa)
      isa = new llvm::GlobalVariable(TheModule, IdTy, /* isConstant */false,
              llvm::GlobalValue::ExternalWeakLinkage, nullptr, Sym);
    else if (isa->getType() != PtrToIdTy)
      isa = llvm::ConstantExpr::getBitCast(isa, PtrToIdTy);
  
    ConstantInitBuilder Builder(CGM);
    auto Fields = Builder.beginStruct();
    Fields.add(isa);
    Fields.add(MakeConstantString(Str));
    Fields.addInt(IntTy, Str.size());
    llvm::Constant *ObjCStr =
      Fields.finishAndCreateGlobal(".objc_str", Align);
    ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStr, PtrToInt8Ty);
    ObjCStrings[Str] = ObjCStr;
    ConstantStrings.push_back(ObjCStr);
    return ConstantAddress(ObjCStr, Align);
  }
  
  ///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.
  RValue
  CGObjCGNU::GenerateMessageSendSuper(CodeGenFunction &CGF,
                                      ReturnValueSlot Return,
                                      QualType ResultType,
                                      Selector Sel,
                                      const ObjCInterfaceDecl *Class,
                                      bool isCategoryImpl,
                                      llvm::Value *Receiver,
                                      bool IsClassMessage,
                                      const CallArgList &CallArgs,
                                      const ObjCMethodDecl *Method) {
    CGBuilderTy &Builder = CGF.Builder;
    if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
      if (Sel == RetainSel || Sel == AutoreleaseSel) {
        return RValue::get(EnforceType(Builder, Receiver,
                    CGM.getTypes().ConvertType(ResultType)));
      }
      if (Sel == ReleaseSel) {
        return RValue::get(nullptr);
      }
    }
  
    llvm::Value *cmd = GetSelector(CGF, Sel);
    CallArgList ActualArgs;
  
    ActualArgs.add(RValue::get(EnforceType(Builder, Receiver, IdTy)), ASTIdTy);
    ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
    ActualArgs.addFrom(CallArgs);
  
    MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
  
    llvm::Value *ReceiverClass = nullptr;
    bool isV2ABI = isRuntime(ObjCRuntime::GNUstep, 2);
    if (isV2ABI) {
      ReceiverClass = GetClassNamed(CGF,
          Class->getSuperClass()->getNameAsString(), /*isWeak*/false);
      if (IsClassMessage)  {
        // Load the isa pointer of the superclass is this is a class method.
        ReceiverClass = Builder.CreateBitCast(ReceiverClass,
                                              llvm::PointerType::getUnqual(IdTy));
        ReceiverClass =
          Builder.CreateAlignedLoad(ReceiverClass, CGF.getPointerAlign());
      }
      ReceiverClass = EnforceType(Builder, ReceiverClass, IdTy);
    } else {
      if (isCategoryImpl) {
        llvm::FunctionCallee classLookupFunction = nullptr;
        if (IsClassMessage)  {
          classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
                IdTy, PtrTy, true), "objc_get_meta_class");
        } else {
          classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
                IdTy, PtrTy, true), "objc_get_class");
        }
        ReceiverClass = Builder.CreateCall(classLookupFunction,
            MakeConstantString(Class->getNameAsString()));
      } else {
        // Set up global aliases for the metaclass or class pointer if they do not
        // already exist.  These will are forward-references which will be set to
        // pointers to the class and metaclass structure created for the runtime
        // load function.  To send a message to super, we look up the value of the
        // super_class pointer from either the class or metaclass structure.
        if (IsClassMessage)  {
          if (!MetaClassPtrAlias) {
            MetaClassPtrAlias = llvm::GlobalAlias::create(
                IdTy->getElementType(), 0, llvm::GlobalValue::InternalLinkage,
                ".objc_metaclass_ref" + Class->getNameAsString(), &TheModule);
          }
          ReceiverClass = MetaClassPtrAlias;
        } else {
          if (!ClassPtrAlias) {
            ClassPtrAlias = llvm::GlobalAlias::create(
                IdTy->getElementType(), 0, llvm::GlobalValue::InternalLinkage,
                ".objc_class_ref" + Class->getNameAsString(), &TheModule);
          }
          ReceiverClass = ClassPtrAlias;
        }
      }
      // Cast the pointer to a simplified version of the class structure
      llvm::Type *CastTy = llvm::StructType::get(IdTy, IdTy);
      ReceiverClass = Builder.CreateBitCast(ReceiverClass,
                                            llvm::PointerType::getUnqual(CastTy));
      // Get the superclass pointer
      ReceiverClass = Builder.CreateStructGEP(CastTy, ReceiverClass, 1);
      // Load the superclass pointer
      ReceiverClass =
        Builder.CreateAlignedLoad(ReceiverClass, CGF.getPointerAlign());
    }
    // Construct the structure used to look up the IMP
    llvm::StructType *ObjCSuperTy =
        llvm::StructType::get(Receiver->getType(), IdTy);
  
    Address ObjCSuper = CGF.CreateTempAlloca(ObjCSuperTy,
                                CGF.getPointerAlign());
  
    Builder.CreateStore(Receiver, Builder.CreateStructGEP(ObjCSuper, 0));
    Builder.CreateStore(ReceiverClass, Builder.CreateStructGEP(ObjCSuper, 1));
  
    ObjCSuper = EnforceType(Builder, ObjCSuper, PtrToObjCSuperTy);
  
    // Get the IMP
    llvm::Value *imp = LookupIMPSuper(CGF, ObjCSuper, cmd, MSI);
    imp = EnforceType(Builder, imp, MSI.MessengerType);
  
    llvm::Metadata *impMD[] = {
        llvm::MDString::get(VMContext, Sel.getAsString()),
        llvm::MDString::get(VMContext, Class->getSuperClass()->getNameAsString()),
        llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
            llvm::Type::getInt1Ty(VMContext), IsClassMessage))};
    llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
  
    CGCallee callee(CGCalleeInfo(), imp);
  
    llvm::CallBase *call;
    RValue msgRet = CGF.EmitCall(MSI.CallInfo, callee, Return, ActualArgs, &call);
    call->setMetadata(msgSendMDKind, node);
    return msgRet;
  }
  
  /// Generate code for a message send expression.
  RValue
  CGObjCGNU::GenerateMessageSend(CodeGenFunction &CGF,
                                 ReturnValueSlot Return,
                                 QualType ResultType,
                                 Selector Sel,
                                 llvm::Value *Receiver,
                                 const CallArgList &CallArgs,
                                 const ObjCInterfaceDecl *Class,
                                 const ObjCMethodDecl *Method) {
    CGBuilderTy &Builder = CGF.Builder;
  
    // Strip out message sends to retain / release in GC mode
    if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
      if (Sel == RetainSel || Sel == AutoreleaseSel) {
        return RValue::get(EnforceType(Builder, Receiver,
                    CGM.getTypes().ConvertType(ResultType)));
      }
      if (Sel == ReleaseSel) {
        return RValue::get(nullptr);
      }
    }
  
    // If the return type is something that goes in an integer register, the
    // runtime will handle 0 returns.  For other cases, we fill in the 0 value
    // ourselves.
    //
    // The language spec says the result of this kind of message send is
    // undefined, but lots of people seem to have forgotten to read that
    // paragraph and insist on sending messages to nil that have structure
    // returns.  With GCC, this generates a random return value (whatever happens
    // to be on the stack / in those registers at the time) on most platforms,
    // and generates an illegal instruction trap on SPARC.  With LLVM it corrupts
    // the stack.
    bool isPointerSizedReturn = (ResultType->isAnyPointerType() ||
        ResultType->isIntegralOrEnumerationType() || ResultType->isVoidType());
  
    llvm::BasicBlock *startBB = nullptr;
    llvm::BasicBlock *messageBB = nullptr;
    llvm::BasicBlock *continueBB = nullptr;
  
    if (!isPointerSizedReturn) {
      startBB = Builder.GetInsertBlock();
      messageBB = CGF.createBasicBlock("msgSend");
      continueBB = CGF.createBasicBlock("continue");
  
      llvm::Value *isNil = Builder.CreateICmpEQ(Receiver,
              llvm::Constant::getNullValue(Receiver->getType()));
      Builder.CreateCondBr(isNil, continueBB, messageBB);
      CGF.EmitBlock(messageBB);
    }
  
    IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
    llvm::Value *cmd;
    if (Method)
      cmd = GetSelector(CGF, Method);
    else
      cmd = GetSelector(CGF, Sel);
    cmd = EnforceType(Builder, cmd, SelectorTy);
    Receiver = EnforceType(Builder, Receiver, IdTy);
  
    llvm::Metadata *impMD[] = {
        llvm::MDString::get(VMContext, Sel.getAsString()),
        llvm::MDString::get(VMContext, Class ? Class->getNameAsString() : ""),
        llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
            llvm::Type::getInt1Ty(VMContext), Class != nullptr))};
    llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
  
    CallArgList ActualArgs;
    ActualArgs.add(RValue::get(Receiver), ASTIdTy);
    ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
    ActualArgs.addFrom(CallArgs);
  
    MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
  
    // Get the IMP to call
    llvm::Value *imp;
  
    // If we have non-legacy dispatch specified, we try using the objc_msgSend()
    // functions.  These are not supported on all platforms (or all runtimes on a
    // given platform), so we
    switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
      case CodeGenOptions::Legacy:
        imp = LookupIMP(CGF, Receiver, cmd, node, MSI);
        break;
      case CodeGenOptions::Mixed:
      case CodeGenOptions::NonLegacy:
        if (CGM.ReturnTypeUsesFPRet(ResultType)) {
          imp =
              CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true),
                                        "objc_msgSend_fpret")
                  .getCallee();
        } else if (CGM.ReturnTypeUsesSRet(MSI.CallInfo)) {
          // The actual types here don't matter - we're going to bitcast the
          // function anyway
          imp =
              CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true),
                                        "objc_msgSend_stret")
                  .getCallee();
        } else {
          imp = CGM.CreateRuntimeFunction(
                       llvm::FunctionType::get(IdTy, IdTy, true), "objc_msgSend")
                    .getCallee();
        }
    }
  
    // Reset the receiver in case the lookup modified it
    ActualArgs[0] = CallArg(RValue::get(Receiver), ASTIdTy);
  
    imp = EnforceType(Builder, imp, MSI.MessengerType);
  
    llvm::CallBase *call;
    CGCallee callee(CGCalleeInfo(), imp);
    RValue msgRet = CGF.EmitCall(MSI.CallInfo, callee, Return, ActualArgs, &call);
    call->setMetadata(msgSendMDKind, node);
  
  
    if (!isPointerSizedReturn) {
      messageBB = CGF.Builder.GetInsertBlock();
      CGF.Builder.CreateBr(continueBB);
      CGF.EmitBlock(continueBB);
      if (msgRet.isScalar()) {
        llvm::Value *v = msgRet.getScalarVal();
        llvm::PHINode *phi = Builder.CreatePHI(v->getType(), 2);
        phi->addIncoming(v, messageBB);
        phi->addIncoming(llvm::Constant::getNullValue(v->getType()), startBB);
        msgRet = RValue::get(phi);
      } else if (msgRet.isAggregate()) {
        Address v = msgRet.getAggregateAddress();
        llvm::PHINode *phi = Builder.CreatePHI(v.getType(), 2);
        llvm::Type *RetTy = v.getElementType();
        Address NullVal = CGF.CreateTempAlloca(RetTy, v.getAlignment(), "null");
        CGF.InitTempAlloca(NullVal, llvm::Constant::getNullValue(RetTy));
        phi->addIncoming(v.getPointer(), messageBB);
        phi->addIncoming(NullVal.getPointer(), startBB);
        msgRet = RValue::getAggregate(Address(phi, v.getAlignment()));
      } else /* isComplex() */ {
        std::pair<llvm::Value*,llvm::Value*> v = msgRet.getComplexVal();
        llvm::PHINode *phi = Builder.CreatePHI(v.first->getType(), 2);
        phi->addIncoming(v.first, messageBB);
        phi->addIncoming(llvm::Constant::getNullValue(v.first->getType()),
            startBB);
        llvm::PHINode *phi2 = Builder.CreatePHI(v.second->getType(), 2);
        phi2->addIncoming(v.second, messageBB);
        phi2->addIncoming(llvm::Constant::getNullValue(v.second->getType()),
            startBB);
        msgRet = RValue::getComplex(phi, phi2);
      }
    }
    return msgRet;
  }
  
  /// Generates a MethodList.  Used in construction of a objc_class and
  /// objc_category structures.
  llvm::Constant *CGObjCGNU::
  GenerateMethodList(StringRef ClassName,
                     StringRef CategoryName,
                     ArrayRef<const ObjCMethodDecl*> Methods,
                     bool isClassMethodList) {
    if (Methods.empty())
      return NULLPtr;
  
    ConstantInitBuilder Builder(CGM);
  
    auto MethodList = Builder.beginStruct();
    MethodList.addNullPointer(CGM.Int8PtrTy);
    MethodList.addInt(Int32Ty, Methods.size());
  
    // Get the method structure type.
    llvm::StructType *ObjCMethodTy =
      llvm::StructType::get(CGM.getLLVMContext(), {
        PtrToInt8Ty, // Really a selector, but the runtime creates it us.
        PtrToInt8Ty, // Method types
        IMPTy        // Method pointer
      });
    bool isV2ABI = isRuntime(ObjCRuntime::GNUstep, 2);
    if (isV2ABI) {
      // size_t size;
      llvm::DataLayout td(&TheModule);
      MethodList.addInt(SizeTy, td.getTypeSizeInBits(ObjCMethodTy) /
          CGM.getContext().getCharWidth());
      ObjCMethodTy =
        llvm::StructType::get(CGM.getLLVMContext(), {
          IMPTy,       // Method pointer
          PtrToInt8Ty, // Selector
          PtrToInt8Ty  // Extended type encoding
        });
    } else {
      ObjCMethodTy =
        llvm::StructType::get(CGM.getLLVMContext(), {
          PtrToInt8Ty, // Really a selector, but the runtime creates it us.
          PtrToInt8Ty, // Method types
          IMPTy        // Method pointer
        });
    }
    auto MethodArray = MethodList.beginArray();
    ASTContext &Context = CGM.getContext();
    for (const auto *OMD : Methods) {
      llvm::Constant *FnPtr =
        TheModule.getFunction(SymbolNameForMethod(ClassName, CategoryName,
                                                  OMD->getSelector(),
                                                  isClassMethodList));
      assert(FnPtr && "Can't generate metadata for method that doesn't exist");
      auto Method = MethodArray.beginStruct(ObjCMethodTy);
      if (isV2ABI) {
        Method.addBitCast(FnPtr, IMPTy);
        Method.add(GetConstantSelector(OMD->getSelector(),
            Context.getObjCEncodingForMethodDecl(OMD)));
        Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(OMD, true)));
      } else {
        Method.add(MakeConstantString(OMD->getSelector().getAsString()));
        Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(OMD)));
        Method.addBitCast(FnPtr, IMPTy);
      }
      Method.finishAndAddTo(MethodArray);
    }
    MethodArray.finishAndAddTo(MethodList);
  
    // Create an instance of the structure
    return MethodList.finishAndCreateGlobal(".objc_method_list",
                                            CGM.getPointerAlign());
  }
  
  /// Generates an IvarList.  Used in construction of a objc_class.
  llvm::Constant *CGObjCGNU::
  GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames,
                   ArrayRef<llvm::Constant *> IvarTypes,
                   ArrayRef<llvm::Constant *> IvarOffsets,
                   ArrayRef<llvm::Constant *> IvarAlign,
                   ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership) {
    if (IvarNames.empty())
      return NULLPtr;
  
    ConstantInitBuilder Builder(CGM);
  
    // Structure containing array count followed by array.
    auto IvarList = Builder.beginStruct();
    IvarList.addInt(IntTy, (int)IvarNames.size());
  
    // Get the ivar structure type.
    llvm::StructType *ObjCIvarTy =
        llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, IntTy);
  
    // Array of ivar structures.
    auto Ivars = IvarList.beginArray(ObjCIvarTy);
    for (unsigned int i = 0, e = IvarNames.size() ; i < e ; i++) {
      auto Ivar = Ivars.beginStruct(ObjCIvarTy);
      Ivar.add(IvarNames[i]);
      Ivar.add(IvarTypes[i]);
      Ivar.add(IvarOffsets[i]);
      Ivar.finishAndAddTo(Ivars);
    }
    Ivars.finishAndAddTo(IvarList);
  
    // Create an instance of the structure
    return IvarList.finishAndCreateGlobal(".objc_ivar_list",
                                          CGM.getPointerAlign());
  }
  
  /// Generate a class structure
  llvm::Constant *CGObjCGNU::GenerateClassStructure(
      llvm::Constant *MetaClass,
      llvm::Constant *SuperClass,
      unsigned info,
      const char *Name,
      llvm::Constant *Version,
      llvm::Constant *InstanceSize,
      llvm::Constant *IVars,
      llvm::Constant *Methods,
      llvm::Constant *Protocols,
      llvm::Constant *IvarOffsets,
      llvm::Constant *Properties,
      llvm::Constant *StrongIvarBitmap,
      llvm::Constant *WeakIvarBitmap,
      bool isMeta) {
    // Set up the class structure
    // Note:  Several of these are char*s when they should be ids.  This is
    // because the runtime performs this translation on load.
    //
    // Fields marked New ABI are part of the GNUstep runtime.  We emit them
    // anyway; the classes will still work with the GNU runtime, they will just
    // be ignored.
    llvm::StructType *ClassTy = llvm::StructType::get(
        PtrToInt8Ty,        // isa
        PtrToInt8Ty,        // super_class
        PtrToInt8Ty,        // name
        LongTy,             // version
        LongTy,             // info
        LongTy,             // instance_size
        IVars->getType(),   // ivars
        Methods->getType(), // methods
        // These are all filled in by the runtime, so we pretend
        PtrTy, // dtable
        PtrTy, // subclass_list
        PtrTy, // sibling_class
        PtrTy, // protocols
        PtrTy, // gc_object_type
        // New ABI:
        LongTy,                 // abi_version
        IvarOffsets->getType(), // ivar_offsets
        Properties->getType(),  // properties
        IntPtrTy,               // strong_pointers
        IntPtrTy                // weak_pointers
        );
  
    ConstantInitBuilder Builder(CGM);
    auto Elements = Builder.beginStruct(ClassTy);
  
    // Fill in the structure
  
    // isa
    Elements.addBitCast(MetaClass, PtrToInt8Ty);
    // super_class
    Elements.add(SuperClass);
    // name
    Elements.add(MakeConstantString(Name, ".class_name"));
    // version
    Elements.addInt(LongTy, 0);
    // info
    Elements.addInt(LongTy, info);
    // instance_size
    if (isMeta) {
      llvm::DataLayout td(&TheModule);
      Elements.addInt(LongTy,
                      td.getTypeSizeInBits(ClassTy) /
                        CGM.getContext().getCharWidth());
    } else
      Elements.add(InstanceSize);
    // ivars
    Elements.add(IVars);
    // methods
    Elements.add(Methods);
    // These are all filled in by the runtime, so we pretend
    // dtable
    Elements.add(NULLPtr);
    // subclass_list
    Elements.add(NULLPtr);
    // sibling_class
    Elements.add(NULLPtr);
    // protocols
    Elements.addBitCast(Protocols, PtrTy);
    // gc_object_type
    Elements.add(NULLPtr);
    // abi_version
    Elements.addInt(LongTy, ClassABIVersion);
    // ivar_offsets
    Elements.add(IvarOffsets);
    // properties
    Elements.add(Properties);
    // strong_pointers
    Elements.add(StrongIvarBitmap);
    // weak_pointers
    Elements.add(WeakIvarBitmap);
    // Create an instance of the structure
    // This is now an externally visible symbol, so that we can speed up class
    // messages in the next ABI.  We may already have some weak references to
    // this, so check and fix them properly.
    std::string ClassSym((isMeta ? "_OBJC_METACLASS_": "_OBJC_CLASS_") +
            std::string(Name));
    llvm::GlobalVariable *ClassRef = TheModule.getNamedGlobal(ClassSym);
    llvm::Constant *Class =
      Elements.finishAndCreateGlobal(ClassSym, CGM.getPointerAlign(), false,
                                     llvm::GlobalValue::ExternalLinkage);
    if (ClassRef) {
      ClassRef->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(Class,
                    ClassRef->getType()));
      ClassRef->removeFromParent();
      Class->setName(ClassSym);
    }
    return Class;
  }
  
  llvm::Constant *CGObjCGNU::
  GenerateProtocolMethodList(ArrayRef<const ObjCMethodDecl*> Methods) {
    // Get the method structure type.
    llvm::StructType *ObjCMethodDescTy =
      llvm::StructType::get(CGM.getLLVMContext(), { PtrToInt8Ty, PtrToInt8Ty });
    ASTContext &Context = CGM.getContext();
    ConstantInitBuilder Builder(CGM);
    auto MethodList = Builder.beginStruct();
    MethodList.addInt(IntTy, Methods.size());
    auto MethodArray = MethodList.beginArray(ObjCMethodDescTy);
    for (auto *M : Methods) {
      auto Method = MethodArray.beginStruct(ObjCMethodDescTy);
      Method.add(MakeConstantString(M->getSelector().getAsString()));
      Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(M)));
      Method.finishAndAddTo(MethodArray);
    }
    MethodArray.finishAndAddTo(MethodList);
    return MethodList.finishAndCreateGlobal(".objc_method_list",
                                            CGM.getPointerAlign());
  }
  
  // Create the protocol list structure used in classes, categories and so on
  llvm::Constant *
  CGObjCGNU::GenerateProtocolList(ArrayRef<std::string> Protocols) {
  
    ConstantInitBuilder Builder(CGM);
    auto ProtocolList = Builder.beginStruct();
    ProtocolList.add(NULLPtr);
    ProtocolList.addInt(LongTy, Protocols.size());
  
    auto Elements = ProtocolList.beginArray(PtrToInt8Ty);
    for (const std::string *iter = Protocols.begin(), *endIter = Protocols.end();
        iter != endIter ; iter++) {
      llvm::Constant *protocol = nullptr;
      llvm::StringMap<llvm::Constant*>::iterator value =
        ExistingProtocols.find(*iter);
      if (value == ExistingProtocols.end()) {
        protocol = GenerateEmptyProtocol(*iter);
      } else {
        protocol = value->getValue();
      }
      Elements.addBitCast(protocol, PtrToInt8Ty);
    }
    Elements.finishAndAddTo(ProtocolList);
    return ProtocolList.finishAndCreateGlobal(".objc_protocol_list",
                                              CGM.getPointerAlign());
  }
  
  llvm::Value *CGObjCGNU::GenerateProtocolRef(CodeGenFunction &CGF,
                                              const ObjCProtocolDecl *PD) {
    llvm::Constant *&protocol = ExistingProtocols[PD->getNameAsString()];
    if (!protocol)
      GenerateProtocol(PD);
    llvm::Type *T =
      CGM.getTypes().ConvertType(CGM.getContext().getObjCProtoType());
    return CGF.Builder.CreateBitCast(protocol, llvm::PointerType::getUnqual(T));
  }
  
  llvm::Constant *
  CGObjCGNU::GenerateEmptyProtocol(StringRef ProtocolName) {
    llvm::Constant *ProtocolList = GenerateProtocolList({});
    llvm::Constant *MethodList = GenerateProtocolMethodList({});
    MethodList = llvm::ConstantExpr::getBitCast(MethodList, PtrToInt8Ty);
    // Protocols are objects containing lists of the methods implemented and
    // protocols adopted.
    ConstantInitBuilder Builder(CGM);
    auto Elements = Builder.beginStruct();
  
    // The isa pointer must be set to a magic number so the runtime knows it's
    // the correct layout.
    Elements.add(llvm::ConstantExpr::getIntToPtr(
            llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
  
    Elements.add(MakeConstantString(ProtocolName, ".objc_protocol_name"));
    Elements.add(ProtocolList); /* .protocol_list */
    Elements.add(MethodList);   /* .instance_methods */
    Elements.add(MethodList);   /* .class_methods */
    Elements.add(MethodList);   /* .optional_instance_methods */
    Elements.add(MethodList);   /* .optional_class_methods */
    Elements.add(NULLPtr);      /* .properties */
    Elements.add(NULLPtr);      /* .optional_properties */
    return Elements.finishAndCreateGlobal(SymbolForProtocol(ProtocolName),
                                          CGM.getPointerAlign());
  }
  
  void CGObjCGNU::GenerateProtocol(const ObjCProtocolDecl *PD) {
    std::string ProtocolName = PD->getNameAsString();
  
    // Use the protocol definition, if there is one.
    if (const ObjCProtocolDecl *Def = PD->getDefinition())
      PD = Def;
  
    SmallVector<std::string, 16> Protocols;
    for (const auto *PI : PD->protocols())
      Protocols.push_back(PI->getNameAsString());
    SmallVector<const ObjCMethodDecl*, 16> InstanceMethods;
    SmallVector<const ObjCMethodDecl*, 16> OptionalInstanceMethods;
    for (const auto *I : PD->instance_methods())
      if (I->isOptional())
        OptionalInstanceMethods.push_back(I);
      else
        InstanceMethods.push_back(I);
    // Collect information about class methods:
    SmallVector<const ObjCMethodDecl*, 16> ClassMethods;
    SmallVector<const ObjCMethodDecl*, 16> OptionalClassMethods;
    for (const auto *I : PD->class_methods())
      if (I->isOptional())
        OptionalClassMethods.push_back(I);
      else
        ClassMethods.push_back(I);
  
    llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);
    llvm::Constant *InstanceMethodList =
      GenerateProtocolMethodList(InstanceMethods);
    llvm::Constant *ClassMethodList =
      GenerateProtocolMethodList(ClassMethods);
    llvm::Constant *OptionalInstanceMethodList =
      GenerateProtocolMethodList(OptionalInstanceMethods);
    llvm::Constant *OptionalClassMethodList =
      GenerateProtocolMethodList(OptionalClassMethods);
  
    // Property metadata: name, attributes, isSynthesized, setter name, setter
    // types, getter name, getter types.
    // The isSynthesized value is always set to 0 in a protocol.  It exists to
    // simplify the runtime library by allowing it to use the same data
    // structures for protocol metadata everywhere.
  
    llvm::Constant *PropertyList =
      GeneratePropertyList(nullptr, PD, false, false);
    llvm::Constant *OptionalPropertyList =
      GeneratePropertyList(nullptr, PD, false, true);
  
    // Protocols are objects containing lists of the methods implemented and
    // protocols adopted.
    // The isa pointer must be set to a magic number so the runtime knows it's
    // the correct layout.
    ConstantInitBuilder Builder(CGM);
    auto Elements = Builder.beginStruct();
    Elements.add(
        llvm::ConstantExpr::getIntToPtr(
            llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
    Elements.add(MakeConstantString(ProtocolName));
    Elements.add(ProtocolList);
    Elements.add(InstanceMethodList);
    Elements.add(ClassMethodList);
    Elements.add(OptionalInstanceMethodList);
    Elements.add(OptionalClassMethodList);
    Elements.add(PropertyList);
    Elements.add(OptionalPropertyList);
    ExistingProtocols[ProtocolName] =
      llvm::ConstantExpr::getBitCast(
        Elements.finishAndCreateGlobal(".objc_protocol", CGM.getPointerAlign()),
        IdTy);
  }
  void CGObjCGNU::GenerateProtocolHolderCategory() {
    // Collect information about instance methods
  
    ConstantInitBuilder Builder(CGM);
    auto Elements = Builder.beginStruct();
  
    const std::string ClassName = "__ObjC_Protocol_Holder_Ugly_Hack";
    const std::string CategoryName = "AnotherHack";
    Elements.add(MakeConstantString(CategoryName));
    Elements.add(MakeConstantString(ClassName));
    // Instance method list
    Elements.addBitCast(GenerateMethodList(
            ClassName, CategoryName, {}, false), PtrTy);
    // Class method list
    Elements.addBitCast(GenerateMethodList(
            ClassName, CategoryName, {}, true), PtrTy);
  
    // Protocol list
    ConstantInitBuilder ProtocolListBuilder(CGM);
    auto ProtocolList = ProtocolListBuilder.beginStruct();
    ProtocolList.add(NULLPtr);
    ProtocolList.addInt(LongTy, ExistingProtocols.size());
    auto ProtocolElements = ProtocolList.beginArray(PtrTy);
    for (auto iter = ExistingProtocols.begin(), endIter = ExistingProtocols.end();
         iter != endIter ; iter++) {
      ProtocolElements.addBitCast(iter->getValue(), PtrTy);
    }
    ProtocolElements.finishAndAddTo(ProtocolList);
    Elements.addBitCast(
                     ProtocolList.finishAndCreateGlobal(".objc_protocol_list",
                                                        CGM.getPointerAlign()),
                     PtrTy);
    Categories.push_back(llvm::ConstantExpr::getBitCast(
          Elements.finishAndCreateGlobal("", CGM.getPointerAlign()),
          PtrTy));
  }
  
  /// Libobjc2 uses a bitfield representation where small(ish) bitfields are
  /// stored in a 64-bit value with the low bit set to 1 and the remaining 63
  /// bits set to their values, LSB first, while larger ones are stored in a
  /// structure of this / form:
  ///
  /// struct { int32_t length; int32_t values[length]; };
  ///
  /// The values in the array are stored in host-endian format, with the least
  /// significant bit being assumed to come first in the bitfield.  Therefore, a
  /// bitfield with the 64th bit set will be (int64_t)&{ 2, [0, 1<<31] }, while a
  /// bitfield / with the 63rd bit set will be 1<<64.
  llvm::Constant *CGObjCGNU::MakeBitField(ArrayRef<bool> bits) {
    int bitCount = bits.size();
    int ptrBits = CGM.getDataLayout().getPointerSizeInBits();
    if (bitCount < ptrBits) {
      uint64_t val = 1;
      for (int i=0 ; i<bitCount ; ++i) {
        if (bits[i]) val |= 1ULL<<(i+1);
      }
      return llvm::ConstantInt::get(IntPtrTy, val);
    }
    SmallVector<llvm::Constant *, 8> values;
    int v=0;
    while (v < bitCount) {
      int32_t word = 0;
      for (int i=0 ; (i<32) && (v<bitCount)  ; ++i) {
        if (bits[v]) word |= 1<<i;
        v++;
      }
      values.push_back(llvm::ConstantInt::get(Int32Ty, word));
    }
  
    ConstantInitBuilder builder(CGM);
    auto fields = builder.beginStruct();
    fields.addInt(Int32Ty, values.size());
    auto array = fields.beginArray();
    for (auto v : values) array.add(v);
    array.finishAndAddTo(fields);
  
    llvm::Constant *GS =
      fields.finishAndCreateGlobal("", CharUnits::fromQuantity(4));
    llvm::Constant *ptr = llvm::ConstantExpr::getPtrToInt(GS, IntPtrTy);
    return ptr;
  }
  
  llvm::Constant *CGObjCGNU::GenerateCategoryProtocolList(const
      ObjCCategoryDecl *OCD) {
    SmallVector<std::string, 16> Protocols;
    for (const auto *PD : OCD->getReferencedProtocols())
      Protocols.push_back(PD->getNameAsString());
    return GenerateProtocolList(Protocols);
  }
  
  void CGObjCGNU::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
    const ObjCInterfaceDecl *Class = OCD->getClassInterface();
    std::string ClassName = Class->getNameAsString();
    std::string CategoryName = OCD->getNameAsString();
  
    // Collect the names of referenced protocols
    const ObjCCategoryDecl *CatDecl = OCD->getCategoryDecl();
  
    ConstantInitBuilder Builder(CGM);
    auto Elements = Builder.beginStruct();
    Elements.add(MakeConstantString(CategoryName));
    Elements.add(MakeConstantString(ClassName));
    // Instance method list
    SmallVector<ObjCMethodDecl*, 16> InstanceMethods;
    InstanceMethods.insert(InstanceMethods.begin(), OCD->instmeth_begin(),
        OCD->instmeth_end());
    Elements.addBitCast(
            GenerateMethodList(ClassName, CategoryName, InstanceMethods, false),
            PtrTy);
    // Class method list
  
    SmallVector<ObjCMethodDecl*, 16> ClassMethods;
    ClassMethods.insert(ClassMethods.begin(), OCD->classmeth_begin(),
        OCD->classmeth_end());
    Elements.addBitCast(
            GenerateMethodList(ClassName, CategoryName, ClassMethods, true),
            PtrTy);
    // Protocol list
    Elements.addBitCast(GenerateCategoryProtocolList(CatDecl), PtrTy);
    if (isRuntime(ObjCRuntime::GNUstep, 2)) {
      const ObjCCategoryDecl *Category =
        Class->FindCategoryDeclaration(OCD->getIdentifier());
      if (Category) {
        // Instance properties
        Elements.addBitCast(GeneratePropertyList(OCD, Category, false), PtrTy);
        // Class properties
        Elements.addBitCast(GeneratePropertyList(OCD, Category, true), PtrTy);
      } else {
        Elements.addNullPointer(PtrTy);
        Elements.addNullPointer(PtrTy);
      }
    }
  
    Categories.push_back(llvm::ConstantExpr::getBitCast(
          Elements.finishAndCreateGlobal(
            std::string(".objc_category_")+ClassName+CategoryName,
            CGM.getPointerAlign()),
          PtrTy));
  }
  
  llvm::Constant *CGObjCGNU::GeneratePropertyList(const Decl *Container,
      const ObjCContainerDecl *OCD,
      bool isClassProperty,
      bool protocolOptionalProperties) {
  
    SmallVector<const ObjCPropertyDecl *, 16> Properties;
    llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
    bool isProtocol = isa<ObjCProtocolDecl>(OCD);
    ASTContext &Context = CGM.getContext();
  
    std::function<void(const ObjCProtocolDecl *Proto)> collectProtocolProperties
      = [&](const ObjCProtocolDecl *Proto) {
        for (const auto *P : Proto->protocols())
          collectProtocolProperties(P);
        for (const auto *PD : Proto->properties()) {
          if (isClassProperty != PD->isClassProperty())
            continue;
          // Skip any properties that are declared in protocols that this class
          // conforms to but are not actually implemented by this class.
          if (!isProtocol && !Context.getObjCPropertyImplDeclForPropertyDecl(PD, Container))
            continue;
          if (!PropertySet.insert(PD->getIdentifier()).second)
            continue;
          Properties.push_back(PD);
        }
      };
  
    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;
          PropertySet.insert(PD->getIdentifier());
          Properties.push_back(PD);
        }
  
    for (const auto *PD : OCD->properties()) {
      if (isClassProperty != PD->isClassProperty())
        continue;
      // If we're generating a list for a protocol, skip optional / required ones
      // when generating the other list.
      if (isProtocol && (protocolOptionalProperties != PD->isOptional()))
        continue;
      // Don't emit duplicate metadata for properties that were already in a
      // class extension.
      if (!PropertySet.insert(PD->getIdentifier()).second)
        continue;
  
      Properties.push_back(PD);
    }
  
    if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
      for (const auto *P : OID->all_referenced_protocols())
        collectProtocolProperties(P);
    else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD))
      for (const auto *P : CD->protocols())
        collectProtocolProperties(P);
  
    auto numProperties = Properties.size();
  
    if (numProperties == 0)
      return NULLPtr;
  
    ConstantInitBuilder builder(CGM);
    auto propertyList = builder.beginStruct();
    auto properties = PushPropertyListHeader(propertyList, numProperties);
  
    // Add all of the property methods need adding to the method list and to the
    // property metadata list.
    for (auto *property : Properties) {
      bool isSynthesized = false;
      bool isDynamic = false;
      if (!isProtocol) {
        auto *propertyImpl = Context.getObjCPropertyImplDeclForPropertyDecl(property, Container);
        if (propertyImpl) {
          isSynthesized = (propertyImpl->getPropertyImplementation() ==
              ObjCPropertyImplDecl::Synthesize);
          isDynamic = (propertyImpl->getPropertyImplementation() ==
              ObjCPropertyImplDecl::Dynamic);
        }
      }
      PushProperty(properties, property, Container, isSynthesized, isDynamic);
    }
    properties.finishAndAddTo(propertyList);
  
    return propertyList.finishAndCreateGlobal(".objc_property_list",
                                              CGM.getPointerAlign());
  }
  
  void CGObjCGNU::RegisterAlias(const ObjCCompatibleAliasDecl *OAD) {
    // Get the class declaration for which the alias is specified.
    ObjCInterfaceDecl *ClassDecl =
      const_cast<ObjCInterfaceDecl *>(OAD->getClassInterface());
    ClassAliases.emplace_back(ClassDecl->getNameAsString(),
                              OAD->getNameAsString());
  }
  
  void CGObjCGNU::GenerateClass(const ObjCImplementationDecl *OID) {
    ASTContext &Context = CGM.getContext();
  
    // Get the superclass name.
    const ObjCInterfaceDecl * SuperClassDecl =
      OID->getClassInterface()->getSuperClass();
    std::string SuperClassName;
    if (SuperClassDecl) {
      SuperClassName = SuperClassDecl->getNameAsString();
      EmitClassRef(SuperClassName);
    }
  
    // Get the class name
    ObjCInterfaceDecl *ClassDecl =
        const_cast<ObjCInterfaceDecl *>(OID->getClassInterface());
    std::string ClassName = ClassDecl->getNameAsString();
  
    // Emit the symbol that is used to generate linker errors if this class is
    // referenced in other modules but not declared.
    std::string classSymbolName = "__objc_class_name_" + ClassName;
    if (auto *symbol = TheModule.getGlobalVariable(classSymbolName)) {
      symbol->setInitializer(llvm::ConstantInt::get(LongTy, 0));
    } else {
      new llvm::GlobalVariable(TheModule, LongTy, false,
                               llvm::GlobalValue::ExternalLinkage,
                               llvm::ConstantInt::get(LongTy, 0),
                               classSymbolName);
    }
  
    // Get the size of instances.
    int instanceSize =
      Context.getASTObjCImplementationLayout(OID).getSize().getQuantity();
  
    // Collect information about instance variables.
    SmallVector<llvm::Constant*, 16> IvarNames;
    SmallVector<llvm::Constant*, 16> IvarTypes;
    SmallVector<llvm::Constant*, 16> IvarOffsets;
    SmallVector<llvm::Constant*, 16> IvarAligns;
    SmallVector<Qualifiers::ObjCLifetime, 16> IvarOwnership;
  
    ConstantInitBuilder IvarOffsetBuilder(CGM);
    auto IvarOffsetValues = IvarOffsetBuilder.beginArray(PtrToIntTy);
    SmallVector<bool, 16> WeakIvars;
    SmallVector<bool, 16> StrongIvars;
  
    int superInstanceSize = !SuperClassDecl ? 0 :
      Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize().getQuantity();
    // For non-fragile ivars, set the instance size to 0 - {the size of just this
    // class}.  The runtime will then set this to the correct value on load.
    if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
      instanceSize = 0 - (instanceSize - superInstanceSize);
    }
  
    for (const ObjCIvarDecl *IVD = ClassDecl->all_declared_ivar_begin(); IVD;
         IVD = IVD->getNextIvar()) {
        // Store the name
        IvarNames.push_back(MakeConstantString(IVD->getNameAsString()));
        // Get the type encoding for this ivar
        std::string TypeStr;
        Context.getObjCEncodingForType(IVD->getType(), TypeStr, IVD);
        IvarTypes.push_back(MakeConstantString(TypeStr));
        IvarAligns.push_back(llvm::ConstantInt::get(IntTy,
              Context.getTypeSize(IVD->getType())));
        // Get the offset
        uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD);
        uint64_t Offset = BaseOffset;
        if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
          Offset = BaseOffset - superInstanceSize;
        }
        llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset);
        // Create the direct offset value
        std::string OffsetName = "__objc_ivar_offset_value_" + ClassName +"." +
            IVD->getNameAsString();
  
        llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName);
        if (OffsetVar) {
          OffsetVar->setInitializer(OffsetValue);
          // If this is the real definition, change its linkage type so that
          // different modules will use this one, rather than their private
          // copy.
          OffsetVar->setLinkage(llvm::GlobalValue::ExternalLinkage);
        } else
          OffsetVar = new llvm::GlobalVariable(TheModule, Int32Ty,
            false, llvm::GlobalValue::ExternalLinkage,
            OffsetValue, OffsetName);
        IvarOffsets.push_back(OffsetValue);
        IvarOffsetValues.add(OffsetVar);
        Qualifiers::ObjCLifetime lt = IVD->getType().getQualifiers().getObjCLifetime();
        IvarOwnership.push_back(lt);
        switch (lt) {
          case Qualifiers::OCL_Strong:
            StrongIvars.push_back(true);
            WeakIvars.push_back(false);
            break;
          case Qualifiers::OCL_Weak:
            StrongIvars.push_back(false);
            WeakIvars.push_back(true);
            break;
          default:
            StrongIvars.push_back(false);
            WeakIvars.push_back(false);
        }
    }
    llvm::Constant *StrongIvarBitmap = MakeBitField(StrongIvars);
    llvm::Constant *WeakIvarBitmap = MakeBitField(WeakIvars);
    llvm::GlobalVariable *IvarOffsetArray =
      IvarOffsetValues.finishAndCreateGlobal(".ivar.offsets",
                                             CGM.getPointerAlign());
  
    // Collect information about instance methods
    SmallVector<const ObjCMethodDecl*, 16> InstanceMethods;
    InstanceMethods.insert(InstanceMethods.begin(), OID->instmeth_begin(),
        OID->instmeth_end());
  
    SmallVector<const ObjCMethodDecl*, 16> ClassMethods;
    ClassMethods.insert(ClassMethods.begin(), OID->classmeth_begin(),
        OID->classmeth_end());
  
    // Collect the same information about synthesized properties, which don't
    // show up in the instance method lists.
    for (auto *propertyImpl : OID->property_impls())
      if (propertyImpl->getPropertyImplementation() ==
          ObjCPropertyImplDecl::Synthesize) {
        ObjCPropertyDecl *property = propertyImpl->getPropertyDecl();
        auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) {
          if (accessor)
            InstanceMethods.push_back(accessor);
        };
        addPropertyMethod(property->getGetterMethodDecl());
        addPropertyMethod(property->getSetterMethodDecl());
      }
  
    llvm::Constant *Properties = GeneratePropertyList(OID, ClassDecl);
  
    // Collect the names of referenced protocols
    SmallVector<std::string, 16> Protocols;
    for (const auto *I : ClassDecl->protocols())
      Protocols.push_back(I->getNameAsString());
  
    // Get the superclass pointer.
    llvm::Constant *SuperClass;
    if (!SuperClassName.empty()) {
      SuperClass = MakeConstantString(SuperClassName, ".super_class_name");
    } else {
      SuperClass = llvm::ConstantPointerNull::get(PtrToInt8Ty);
    }
    // Empty vector used to construct empty method lists
    SmallVector<llvm::Constant*, 1>  empty;
    // Generate the method and instance variable lists
    llvm::Constant *MethodList = GenerateMethodList(ClassName, "",
        InstanceMethods, false);
    llvm::Constant *ClassMethodList = GenerateMethodList(ClassName, "",
        ClassMethods, true);
    llvm::Constant *IvarList = GenerateIvarList(IvarNames, IvarTypes,
        IvarOffsets, IvarAligns, IvarOwnership);
    // Irrespective of whether we are compiling for a fragile or non-fragile ABI,
    // we emit a symbol containing the offset for each ivar in the class.  This
    // allows code compiled for the non-Fragile ABI to inherit from code compiled
    // for the legacy ABI, without causing problems.  The converse is also
    // possible, but causes all ivar accesses to be fragile.
  
    // Offset pointer for getting at the correct field in the ivar list when
    // setting up the alias.  These are: The base address for the global, the
    // ivar array (second field), the ivar in this list (set for each ivar), and
    // the offset (third field in ivar structure)
    llvm::Type *IndexTy = Int32Ty;
    llvm::Constant *offsetPointerIndexes[] = {Zeros[0],
        llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 2 : 1), nullptr,
        llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 3 : 2) };
  
    unsigned ivarIndex = 0;
    for (const ObjCIvarDecl *IVD = ClassDecl->all_declared_ivar_begin(); IVD;
         IVD = IVD->getNextIvar()) {
        const std::string Name = GetIVarOffsetVariableName(ClassDecl, IVD);
        offsetPointerIndexes[2] = llvm::ConstantInt::get(IndexTy, ivarIndex);
        // Get the correct ivar field
        llvm::Constant *offsetValue = llvm::ConstantExpr::getGetElementPtr(
            cast<llvm::GlobalVariable>(IvarList)->getValueType(), IvarList,
            offsetPointerIndexes);
        // Get the existing variable, if one exists.
        llvm::GlobalVariable *offset = TheModule.getNamedGlobal(Name);
        if (offset) {
          offset->setInitializer(offsetValue);
          // If this is the real definition, change its linkage type so that
          // different modules will use this one, rather than their private
          // copy.
          offset->setLinkage(llvm::GlobalValue::ExternalLinkage);
        } else
          // Add a new alias if there isn't one already.
          new llvm::GlobalVariable(TheModule, offsetValue->getType(),
                  false, llvm::GlobalValue::ExternalLinkage, offsetValue, Name);
        ++ivarIndex;
    }
    llvm::Constant *ZeroPtr = llvm::ConstantInt::get(IntPtrTy, 0);
  
    //Generate metaclass for class methods
    llvm::Constant *MetaClassStruct = GenerateClassStructure(
        NULLPtr, NULLPtr, 0x12L, ClassName.c_str(), nullptr, Zeros[0],
        NULLPtr, ClassMethodList, NULLPtr, NULLPtr,
        GeneratePropertyList(OID, ClassDecl, true), ZeroPtr, ZeroPtr, true);
    CGM.setGVProperties(cast<llvm::GlobalValue>(MetaClassStruct),
                        OID->getClassInterface());
  
    // Generate the class structure
    llvm::Constant *ClassStruct = GenerateClassStructure(
        MetaClassStruct, SuperClass, 0x11L, ClassName.c_str(), nullptr,
        llvm::ConstantInt::get(LongTy, instanceSize), IvarList, MethodList,
        GenerateProtocolList(Protocols), IvarOffsetArray, Properties,
        StrongIvarBitmap, WeakIvarBitmap);
    CGM.setGVProperties(cast<llvm::GlobalValue>(ClassStruct),
                        OID->getClassInterface());
  
    // Resolve the class aliases, if they exist.
    if (ClassPtrAlias) {
      ClassPtrAlias->replaceAllUsesWith(
          llvm::ConstantExpr::getBitCast(ClassStruct, IdTy));
      ClassPtrAlias->eraseFromParent();
      ClassPtrAlias = nullptr;
    }
    if (MetaClassPtrAlias) {
      MetaClassPtrAlias->replaceAllUsesWith(
          llvm::ConstantExpr::getBitCast(MetaClassStruct, IdTy));
      MetaClassPtrAlias->eraseFromParent();
      MetaClassPtrAlias = nullptr;
    }
  
    // Add class structure to list to be added to the symtab later
    ClassStruct = llvm::ConstantExpr::getBitCast(ClassStruct, PtrToInt8Ty);
    Classes.push_back(ClassStruct);
  }
  
  llvm::Function *CGObjCGNU::ModuleInitFunction() {
    // Only emit an ObjC load function if no Objective-C stuff has been called
    if (Classes.empty() && Categories.empty() && ConstantStrings.empty() &&
        ExistingProtocols.empty() && SelectorTable.empty())
      return nullptr;
  
    // Add all referenced protocols to a category.
    GenerateProtocolHolderCategory();
  
    llvm::StructType *selStructTy =
      dyn_cast<llvm::StructType>(SelectorTy->getElementType());
    llvm::Type *selStructPtrTy = SelectorTy;
    if (!selStructTy) {
      selStructTy = llvm::StructType::get(CGM.getLLVMContext(),
                                          { PtrToInt8Ty, PtrToInt8Ty });
      selStructPtrTy = llvm::PointerType::getUnqual(selStructTy);
    }
  
    // Generate statics list:
    llvm::Constant *statics = NULLPtr;
    if (!ConstantStrings.empty()) {
      llvm::GlobalVariable *fileStatics = [&] {
        ConstantInitBuilder builder(CGM);
        auto staticsStruct = builder.beginStruct();
  
        StringRef stringClass = CGM.getLangOpts().ObjCConstantStringClass;
        if (stringClass.empty()) stringClass = "NXConstantString";
        staticsStruct.add(MakeConstantString(stringClass,
                                             ".objc_static_class_name"));
  
        auto array = staticsStruct.beginArray();
        array.addAll(ConstantStrings);
        array.add(NULLPtr);
        array.finishAndAddTo(staticsStruct);
  
        return staticsStruct.finishAndCreateGlobal(".objc_statics",
                                                   CGM.getPointerAlign());
      }();
  
      ConstantInitBuilder builder(CGM);
      auto allStaticsArray = builder.beginArray(fileStatics->getType());
      allStaticsArray.add(fileStatics);
      allStaticsArray.addNullPointer(fileStatics->getType());
  
      statics = allStaticsArray.finishAndCreateGlobal(".objc_statics_ptr",
                                                      CGM.getPointerAlign());
      statics = llvm::ConstantExpr::getBitCast(statics, PtrTy);
    }
  
    // Array of classes, categories, and constant objects.
  
    SmallVector<llvm::GlobalAlias*, 16> selectorAliases;
    unsigned selectorCount;
  
    // Pointer to an array of selectors used in this module.
    llvm::GlobalVariable *selectorList = [&] {
      ConstantInitBuilder builder(CGM);
      auto selectors = builder.beginArray(selStructTy);
      auto &table = SelectorTable; // MSVC workaround
      std::vector<Selector> allSelectors;
      for (auto &entry : table)
        allSelectors.push_back(entry.first);
      llvm::sort(allSelectors);
  
      for (auto &untypedSel : allSelectors) {
        std::string selNameStr = untypedSel.getAsString();
        llvm::Constant *selName = ExportUniqueString(selNameStr, ".objc_sel_name");
  
        for (TypedSelector &sel : table[untypedSel]) {
          llvm::Constant *selectorTypeEncoding = NULLPtr;
          if (!sel.first.empty())
            selectorTypeEncoding =
              MakeConstantString(sel.first, ".objc_sel_types");
  
          auto selStruct = selectors.beginStruct(selStructTy);
          selStruct.add(selName);
          selStruct.add(selectorTypeEncoding);
          selStruct.finishAndAddTo(selectors);
  
          // Store the selector alias for later replacement
          selectorAliases.push_back(sel.second);
        }
      }
  
      // Remember the number of entries in the selector table.
      selectorCount = selectors.size();
  
      // NULL-terminate the selector list.  This should not actually be required,
      // because the selector list has a length field.  Unfortunately, the GCC
      // runtime decides to ignore the length field and expects a NULL terminator,
      // and GCC cooperates with this by always setting the length to 0.
      auto selStruct = selectors.beginStruct(selStructTy);
      selStruct.add(NULLPtr);
      selStruct.add(NULLPtr);
      selStruct.finishAndAddTo(selectors);
  
      return selectors.finishAndCreateGlobal(".objc_selector_list",
                                             CGM.getPointerAlign());
    }();
  
    // Now that all of the static selectors exist, create pointers to them.
    for (unsigned i = 0; i < selectorCount; ++i) {
      llvm::Constant *idxs[] = {
        Zeros[0],
        llvm::ConstantInt::get(Int32Ty, i)
      };
      // FIXME: We're generating redundant loads and stores here!
      llvm::Constant *selPtr = llvm::ConstantExpr::getGetElementPtr(
          selectorList->getValueType(), selectorList, idxs);
      // If selectors are defined as an opaque type, cast the pointer to this
      // type.
      selPtr = llvm::ConstantExpr::getBitCast(selPtr, SelectorTy);
      selectorAliases[i]->replaceAllUsesWith(selPtr);
      selectorAliases[i]->eraseFromParent();
    }
  
    llvm::GlobalVariable *symtab = [&] {
      ConstantInitBuilder builder(CGM);
      auto symtab = builder.beginStruct();
  
      // Number of static selectors
      symtab.addInt(LongTy, selectorCount);
  
      symtab.addBitCast(selectorList, selStructPtrTy);
  
      // Number of classes defined.
      symtab.addInt(CGM.Int16Ty, Classes.size());
      // Number of categories defined
      symtab.addInt(CGM.Int16Ty, Categories.size());
  
      // Create an array of classes, then categories, then static object instances
      auto classList = symtab.beginArray(PtrToInt8Ty);
      classList.addAll(Classes);
      classList.addAll(Categories);
      //  NULL-terminated list of static object instances (mainly constant strings)
      classList.add(statics);
      classList.add(NULLPtr);
      classList.finishAndAddTo(symtab);
  
      // Construct the symbol table.
      return symtab.finishAndCreateGlobal("", CGM.getPointerAlign());
    }();
  
    // The symbol table is contained in a module which has some version-checking
    // constants
    llvm::Constant *module = [&] {
      llvm::Type *moduleEltTys[] = {
        LongTy, LongTy, PtrToInt8Ty, symtab->getType(), IntTy
      };
      llvm::StructType *moduleTy =
        llvm::StructType::get(CGM.getLLVMContext(),
           makeArrayRef(moduleEltTys).drop_back(unsigned(RuntimeVersion < 10)));
  
      ConstantInitBuilder builder(CGM);
      auto module = builder.beginStruct(moduleTy);
      // Runtime version, used for ABI compatibility checking.
      module.addInt(LongTy, RuntimeVersion);
      // sizeof(ModuleTy)
      module.addInt(LongTy, CGM.getDataLayout().getTypeStoreSize(moduleTy));
  
      // The path to the source file where this module was declared
      SourceManager &SM = CGM.getContext().getSourceManager();
      const FileEntry *mainFile = SM.getFileEntryForID(SM.getMainFileID());
      std::string path =
        (Twine(mainFile->getDir()->getName()) + "/" + mainFile->getName()).str();
      module.add(MakeConstantString(path, ".objc_source_file_name"));
      module.add(symtab);
  
      if (RuntimeVersion >= 10) {
        switch (CGM.getLangOpts().getGC()) {
        case LangOptions::GCOnly:
          module.addInt(IntTy, 2);
          break;
        case LangOptions::NonGC:
          if (CGM.getLangOpts().ObjCAutoRefCount)
            module.addInt(IntTy, 1);
          else
            module.addInt(IntTy, 0);
          break;
        case LangOptions::HybridGC:
          module.addInt(IntTy, 1);
          break;
        }
      }
  
      return module.finishAndCreateGlobal("", CGM.getPointerAlign());
    }();
  
    // Create the load function calling the runtime entry point with the module
    // structure
    llvm::Function * LoadFunction = llvm::Function::Create(
        llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
        llvm::GlobalValue::InternalLinkage, ".objc_load_function",
        &TheModule);
    llvm::BasicBlock *EntryBB =
        llvm::BasicBlock::Create(VMContext, "entry", LoadFunction);
    CGBuilderTy Builder(CGM, VMContext);
    Builder.SetInsertPoint(EntryBB);
  
    llvm::FunctionType *FT =
      llvm::FunctionType::get(Builder.getVoidTy(), module->getType(), true);
    llvm::FunctionCallee Register =
        CGM.CreateRuntimeFunction(FT, "__objc_exec_class");
    Builder.CreateCall(Register, module);
  
    if (!ClassAliases.empty()) {
      llvm::Type *ArgTypes[2] = {PtrTy, PtrToInt8Ty};
      llvm::FunctionType *RegisterAliasTy =
        llvm::FunctionType::get(Builder.getVoidTy(),
                                ArgTypes, false);
      llvm::Function *RegisterAlias = llvm::Function::Create(
        RegisterAliasTy,
        llvm::GlobalValue::ExternalWeakLinkage, "class_registerAlias_np",
        &TheModule);
      llvm::BasicBlock *AliasBB =
        llvm::BasicBlock::Create(VMContext, "alias", LoadFunction);
      llvm::BasicBlock *NoAliasBB =
        llvm::BasicBlock::Create(VMContext, "no_alias", LoadFunction);
  
      // Branch based on whether the runtime provided class_registerAlias_np()
      llvm::Value *HasRegisterAlias = Builder.CreateICmpNE(RegisterAlias,
              llvm::Constant::getNullValue(RegisterAlias->getType()));
      Builder.CreateCondBr(HasRegisterAlias, AliasBB, NoAliasBB);
  
      // The true branch (has alias registration function):
      Builder.SetInsertPoint(AliasBB);
      // Emit alias registration calls:
      for (std::vector<ClassAliasPair>::iterator iter = ClassAliases.begin();
         iter != ClassAliases.end(); ++iter) {
         llvm::Constant *TheClass =
            TheModule.getGlobalVariable("_OBJC_CLASS_" + iter->first, true);
         if (TheClass) {
           TheClass = llvm::ConstantExpr::getBitCast(TheClass, PtrTy);
           Builder.CreateCall(RegisterAlias,
                              {TheClass, MakeConstantString(iter->second)});
         }
      }
      // Jump to end:
      Builder.CreateBr(NoAliasBB);
  
      // Missing alias registration function, just return from the function:
      Builder.SetInsertPoint(NoAliasBB);
    }
    Builder.CreateRetVoid();
  
    return LoadFunction;
  }
  
  llvm::Function *CGObjCGNU::GenerateMethod(const ObjCMethodDecl *OMD,
                                            const ObjCContainerDecl *CD) {
    const ObjCCategoryImplDecl *OCD =
      dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext());
    StringRef CategoryName = OCD ? OCD->getName() : "";
    StringRef ClassName = CD->getName();
    Selector MethodName = OMD->getSelector();
    bool isClassMethod = !OMD->isInstanceMethod();
  
    CodeGenTypes &Types = CGM.getTypes();
    llvm::FunctionType *MethodTy =
      Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
    std::string FunctionName = SymbolNameForMethod(ClassName, CategoryName,
        MethodName, isClassMethod);
  
    llvm::Function *Method
      = llvm::Function::Create(MethodTy,
                               llvm::GlobalValue::InternalLinkage,
                               FunctionName,
                               &TheModule);
    return Method;
  }
  
  llvm::FunctionCallee CGObjCGNU::GetPropertyGetFunction() {
    return GetPropertyFn;
  }
  
  llvm::FunctionCallee CGObjCGNU::GetPropertySetFunction() {
    return SetPropertyFn;
  }
  
  llvm::FunctionCallee CGObjCGNU::GetOptimizedPropertySetFunction(bool atomic,
                                                                  bool copy) {
    return nullptr;
  }
  
  llvm::FunctionCallee CGObjCGNU::GetGetStructFunction() {
    return GetStructPropertyFn;
  }
  
  llvm::FunctionCallee CGObjCGNU::GetSetStructFunction() {
    return SetStructPropertyFn;
  }
  
  llvm::FunctionCallee CGObjCGNU::GetCppAtomicObjectGetFunction() {
    return nullptr;
  }
  
  llvm::FunctionCallee CGObjCGNU::GetCppAtomicObjectSetFunction() {
    return nullptr;
  }
  
  llvm::FunctionCallee CGObjCGNU::EnumerationMutationFunction() {
    return EnumerationMutationFn;
  }
  
  void CGObjCGNU::EmitSynchronizedStmt(CodeGenFunction &CGF,
                                       const ObjCAtSynchronizedStmt &S) {
    EmitAtSynchronizedStmt(CGF, S, SyncEnterFn, SyncExitFn);
  }
  
  
  void CGObjCGNU::EmitTryStmt(CodeGenFunction &CGF,
                              const ObjCAtTryStmt &S) {
    // Unlike the Apple non-fragile runtimes, which also uses
    // unwind-based zero cost exceptions, the GNU Objective C runtime's
    // EH support isn't a veneer over C++ EH.  Instead, exception
    // objects are created by objc_exception_throw and destroyed by
    // the personality function; this avoids the need for bracketing
    // catch handlers with calls to __blah_begin_catch/__blah_end_catch
    // (or even _Unwind_DeleteException), but probably doesn't
    // interoperate very well with foreign exceptions.
    //
    // In Objective-C++ mode, we actually emit something equivalent to the C++
    // exception handler.
    EmitTryCatchStmt(CGF, S, EnterCatchFn, ExitCatchFn, ExceptionReThrowFn);
  }
  
  void CGObjCGNU::EmitThrowStmt(CodeGenFunction &CGF,
                                const ObjCAtThrowStmt &S,
                                bool ClearInsertionPoint) {
    llvm::Value *ExceptionAsObject;
    bool isRethrow = false;
  
    if (const Expr *ThrowExpr = S.getThrowExpr()) {
      llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
      ExceptionAsObject = Exception;
    } else {
      assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
             "Unexpected rethrow outside @catch block.");
      ExceptionAsObject = CGF.ObjCEHValueStack.back();
      isRethrow = true;
    }
    if (isRethrow && usesSEHExceptions) {
      // For SEH, ExceptionAsObject may be undef, because the catch handler is
      // not passed it for catchalls and so it is not visible to the catch
      // funclet.  The real thrown object will still be live on the stack at this
      // point and will be rethrown.  If we are explicitly rethrowing the object
      // that was passed into the `@catch` block, then this code path is not
      // reached and we will instead call `objc_exception_throw` with an explicit
      // argument.
      llvm::CallBase *Throw = CGF.EmitRuntimeCallOrInvoke(ExceptionReThrowFn);
      Throw->setDoesNotReturn();
    }
    else {
      ExceptionAsObject = CGF.Builder.CreateBitCast(ExceptionAsObject, IdTy);
      llvm::CallBase *Throw =
          CGF.EmitRuntimeCallOrInvoke(ExceptionThrowFn, ExceptionAsObject);
      Throw->setDoesNotReturn();
    }
    CGF.Builder.CreateUnreachable();
    if (ClearInsertionPoint)
      CGF.Builder.ClearInsertionPoint();
  }
  
  llvm::Value * CGObjCGNU::EmitObjCWeakRead(CodeGenFunction &CGF,
                                            Address AddrWeakObj) {
    CGBuilderTy &B = CGF.Builder;
    AddrWeakObj = EnforceType(B, AddrWeakObj, PtrToIdTy);
    return B.CreateCall(WeakReadFn, AddrWeakObj.getPointer());
  }
  
  void CGObjCGNU::EmitObjCWeakAssign(CodeGenFunction &CGF,
                                     llvm::Value *src, Address dst) {
    CGBuilderTy &B = CGF.Builder;
    src = EnforceType(B, src, IdTy);
    dst = EnforceType(B, dst, PtrToIdTy);
    B.CreateCall(WeakAssignFn, {src, dst.getPointer()});
  }
  
  void CGObjCGNU::EmitObjCGlobalAssign(CodeGenFunction &CGF,
                                       llvm::Value *src, Address dst,
                                       bool threadlocal) {
    CGBuilderTy &B = CGF.Builder;
    src = EnforceType(B, src, IdTy);
    dst = EnforceType(B, dst, PtrToIdTy);
    // FIXME. Add threadloca assign API
    assert(!threadlocal && "EmitObjCGlobalAssign - Threal Local API NYI");
    B.CreateCall(GlobalAssignFn, {src, dst.getPointer()});
  }
  
  void CGObjCGNU::EmitObjCIvarAssign(CodeGenFunction &CGF,
                                     llvm::Value *src, Address dst,
                                     llvm::Value *ivarOffset) {
    CGBuilderTy &B = CGF.Builder;
    src = EnforceType(B, src, IdTy);
    dst = EnforceType(B, dst, IdTy);
    B.CreateCall(IvarAssignFn, {src, dst.getPointer(), ivarOffset});
  }
  
  void CGObjCGNU::EmitObjCStrongCastAssign(CodeGenFunction &CGF,
                                           llvm::Value *src, Address dst) {
    CGBuilderTy &B = CGF.Builder;
    src = EnforceType(B, src, IdTy);
    dst = EnforceType(B, dst, PtrToIdTy);
    B.CreateCall(StrongCastAssignFn, {src, dst.getPointer()});
  }
  
  void CGObjCGNU::EmitGCMemmoveCollectable(CodeGenFunction &CGF,
                                           Address DestPtr,
                                           Address SrcPtr,
                                           llvm::Value *Size) {
    CGBuilderTy &B = CGF.Builder;
    DestPtr = EnforceType(B, DestPtr, PtrTy);
    SrcPtr = EnforceType(B, SrcPtr, PtrTy);
  
    B.CreateCall(MemMoveFn, {DestPtr.getPointer(), SrcPtr.getPointer(), Size});
  }
  
  llvm::GlobalVariable *CGObjCGNU::ObjCIvarOffsetVariable(
                                const ObjCInterfaceDecl *ID,
                                const ObjCIvarDecl *Ivar) {
    const std::string Name = GetIVarOffsetVariableName(ID, Ivar);
    // Emit the variable and initialize it with what we think the correct value
    // is.  This allows code compiled with non-fragile ivars to work correctly
    // when linked against code which isn't (most of the time).
    llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name);
    if (!IvarOffsetPointer)
      IvarOffsetPointer = new llvm::GlobalVariable(TheModule,
              llvm::Type::getInt32PtrTy(VMContext), false,
              llvm::GlobalValue::ExternalLinkage, nullptr, Name);
    return IvarOffsetPointer;
  }
  
  LValue CGObjCGNU::EmitObjCValueForIvar(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));
  }
  
  static const ObjCInterfaceDecl *FindIvarInterface(ASTContext &Context,
                                                    const ObjCInterfaceDecl *OID,
                                                    const ObjCIvarDecl *OIVD) {
    for (const ObjCIvarDecl *next = OID->all_declared_ivar_begin(); next;
         next = next->getNextIvar()) {
      if (OIVD == next)
        return OID;
    }
  
    // Otherwise check in the super class.
    if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
      return FindIvarInterface(Context, Super, OIVD);
  
    return nullptr;
  }
  
  llvm::Value *CGObjCGNU::EmitIvarOffset(CodeGenFunction &CGF,
                           const ObjCInterfaceDecl *Interface,
                           const ObjCIvarDecl *Ivar) {
    if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
      Interface = FindIvarInterface(CGM.getContext(), Interface, Ivar);
  
      // The MSVC linker cannot have a single global defined as LinkOnceAnyLinkage
      // and ExternalLinkage, so create a reference to the ivar global and rely on
      // the definition being created as part of GenerateClass.
      if (RuntimeVersion < 10 ||
          CGF.CGM.getTarget().getTriple().isKnownWindowsMSVCEnvironment())
        return CGF.Builder.CreateZExtOrBitCast(
            CGF.Builder.CreateAlignedLoad(
                Int32Ty, CGF.Builder.CreateAlignedLoad(
                             ObjCIvarOffsetVariable(Interface, Ivar),
                             CGF.getPointerAlign(), "ivar"),
                CharUnits::fromQuantity(4)),
            PtrDiffTy);
      std::string name = "__objc_ivar_offset_value_" +
        Interface->getNameAsString() +"." + Ivar->getNameAsString();
      CharUnits Align = CGM.getIntAlign();
      llvm::Value *Offset = TheModule.getGlobalVariable(name);
      if (!Offset) {
        auto GV = new llvm::GlobalVariable(TheModule, IntTy,
            false, llvm::GlobalValue::LinkOnceAnyLinkage,
            llvm::Constant::getNullValue(IntTy), name);
        GV->setAlignment(Align.getAsAlign());
        Offset = GV;
      }
      Offset = CGF.Builder.CreateAlignedLoad(Offset, Align);
      if (Offset->getType() != PtrDiffTy)
        Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy);
      return Offset;
    }
    uint64_t Offset = ComputeIvarBaseOffset(CGF.CGM, Interface, Ivar);
    return llvm::ConstantInt::get(PtrDiffTy, Offset, /*isSigned*/true);
  }
  
  CGObjCRuntime *
  clang::CodeGen::CreateGNUObjCRuntime(CodeGenModule &CGM) {
    auto Runtime = CGM.getLangOpts().ObjCRuntime;
    switch (Runtime.getKind()) {
    case ObjCRuntime::GNUstep:
      if (Runtime.getVersion() >= VersionTuple(2, 0))
        return new CGObjCGNUstep2(CGM);
      return new CGObjCGNUstep(CGM);
  
    case ObjCRuntime::GCC:
      return new CGObjCGCC(CGM);
  
    case ObjCRuntime::ObjFW:
      return new CGObjCObjFW(CGM);
  
    case ObjCRuntime::FragileMacOSX:
    case ObjCRuntime::MacOSX:
    case ObjCRuntime::iOS:
    case ObjCRuntime::WatchOS:
      llvm_unreachable("these runtimes are not GNU runtimes");
    }
    llvm_unreachable("bad runtime");
  }
  