[ObjCMetadata] Add support for reading Objective-C metadata

[steven_wu]

Summary

Add a new library to LLVM that can read Objective-C metadata from
binaries or llvm bitcode generation by clang/swift compiler.

[theraven]

I am not convinced that there is sufficient abstraction here to handle multiple runtimes without significant code duplication. The Mach-O and LLVM IR parsers both appear to duplicate all knowledge of the runtime's data structures, so if you wanted to add a second runtime you'd then need four classes. I would expect to see two abstraction layers:

1. Something allowing you to specify a data structure to examine that would load it from some binary (IR, Mach-O, ELF, whatever).
2. Something built on top of this that then queries specific runtime metadata structures.

In clang, we support two broad families of Objective-C runtime: Apple (Legacy and Modern, with version-specific things for macOS, iOS, and so on) and GNU (including GCC, GNUstep / WinObjC, and ObjFW). These are largely orthogonal to object file formats. For example, the GNUstep runtime is widely used with both ELF and PE/COFF binaries and can be used with Mach-O (though typically only for testing). If we wanted to add support for all of these, I suspect that we'd have a code explosion.

[steven_wu]

In D59945#1449696, @theraven wrote:

I am not convinced that there is sufficient abstraction here to handle multiple runtimes without significant code duplication. The Mach-O and LLVM IR parsers both appear to duplicate all knowledge of the runtime's data structures, so if you wanted to add a second runtime you'd then need four classes. I would expect to see two abstraction layers:

1. Something allowing you to specify a data structure to examine that would load it from some binary (IR, Mach-O, ELF, whatever).
2. Something built on top of this that then queries specific runtime metadata structures.

In clang, we support two broad families of Objective-C runtime: Apple (Legacy and Modern, with version-specific things for macOS, iOS, and so on) and GNU (including GCC, GNUstep / WinObjC, and ObjFW). These are largely orthogonal to object file formats. For example, the GNUstep runtime is widely used with both ELF and PE/COFF binaries and can be used with Mach-O (though typically only for testing). If we wanted to add support for all of these, I suspect that we'd have a code explosion.

I understand the concern. When I say the library has the abstraction to support multiple runtime and object file format in RFC, I was talking about the interface of the metadata reader. The design choice is not to expose runtime data structure to the library interfaces so there can be a unified interface no matter what the actual object file and runtime is used. The prototype has implemented Apple (both legacy and modern) with Macho and LLVM bitcode object file format. With how different the data structures really are, that aren't much sharing between implementations. There is potential to add another layer of abstraction of object file format underneath to eliminate some boiler plates (and those should probably add to libObject directly). If you have better idea and design, please let me know.

[steven_wu]

Rebase the patch and did some fixup:

• Fold objective-c metadata reader into object
• Update the lisence header
• clang-format

There is still lots of boiler plates but we can improve that in tree.

[steven_wu]

Rebase the patch to TOT. Ping again.

[ributzka]

llvm/include/llvm/Object/ObjCMetadata/ObjCBitcode.h

31

We could change the interface to

Expected<unsigned> getSwiftABIVersion() const

instead. That removes the need to map the ABI version to a string.

llvm/include/llvm/Object/ObjCMetadata/ObjCBitcode.h

+//===- ObjCBitcode.h - ObjC Metadata Bitcode Interface ----------*- C++ -*-===//
+//
+// 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 file declares ObjCBitcode interface.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJCMETADATA_OBJCBITCODE_H
+#define LLVM_OBJCMETADATA_OBJCBITCODE_H
+
+#include <llvm/ADT/SmallVector.h>
+#include <llvm/ADT/Triple.h>
+#include <llvm/IR/Constants.h>
+#include <llvm/IR/GlobalValue.h>
+#include <llvm/IR/Module.h>
+#include <llvm/Object/ObjCMetadata/ObjCMetadata.h>
+
+namespace llvm {
+
+class BitcodeMetadata : public ObjCMetaDataReader {
+public:
+  BitcodeMetadata(Module *M);
+
+  bool isObjC1() const override;
+  bool isObjC2() const override;
+  Expected<StringRef> getSwiftVersion() const override;
+
+  const Module *getOwningModule() const { return OwningModule; }
+
+  // Overrides ObjC Class Ref Implementation.
+  Expected<ObjCClassList> classes() const override;
+  Expected<ObjCClass> getObjCClassFromRef(ObjCClassRef Ref) const override;
+  bool isObjCClassExternal(ObjCClassRef Ref) const override;
+
+  // Overrides ObjC Category Ref Implementation.
+  Expected<ObjCCategoryList> categories() const override;
+  Expected<ObjCCategory>
+  getObjCCategoryFromRef(ObjCCategoryRef Ref) const override;
+
+  // Overrides ObjC Protocol Ref Implementation.
+  Expected<ObjCProtocolList> protocols() const override;
+  Expected<ObjCProtocol>
+  getObjCProtocolFromRef(ObjCProtocolRef Ref) const override;
+
+  // Overrides ObjC Class Implementation.
+  Expected<StringRef> getObjCClassName(ObjCClass ClassRef) const override;
+  Expected<StringRef> getObjCSuperClassName(ObjCClass Data) const override;
+  Expected<bool> isObjCClassSwift(ObjCClass Data) const override;
+  Expected<bool> isObjCClassMetaClass(ObjCClass Data) const override;
+  Expected<ObjCPropertyList>
+  materializePropertyList(ObjCClass Data) const override;
+  Expected<ObjCPropertyList>
+  materializeClassPropertyList(ObjCClass Data) const override;
+  Expected<ObjCMethodList>
+  materializeInstanceMethodList(ObjCClass Data) const override;
+  Expected<ObjCMethodList>
+  materializeClassMethodList(ObjCClass Data) const override;
+
+  // Overrides ObjC Category Implementation.
+  Expected<StringRef> getObjCCategoryName(ObjCCategory Data) const override;
+  Expected<StringRef>
+  getObjCCategoryBaseClassName(ObjCCategory Data) const override;
+  Expected<ObjCPropertyList>
+  materializePropertyList(ObjCCategory Data) const override;
+  Expected<ObjCMethodList>
+  materializeInstanceMethodList(ObjCCategory Data) const override;
+  Expected<ObjCMethodList>
+  materializeClassMethodList(ObjCCategory Data) const override;
+
+  // Overrides ObjC Protocol Implementation.
+  Expected<StringRef> getObjCProtocolName(ObjCProtocol Data) const override;
+  Expected<ObjCPropertyList>
+  materializePropertyList(ObjCProtocol Data) const override;
+  Expected<ObjCMethodList>
+  materializeInstanceMethodList(ObjCProtocol Data) const override;
+  Expected<ObjCMethodList>
+  materializeClassMethodList(ObjCProtocol Data) const override;
+  Expected<ObjCMethodList>
+  materializeOptionalInstanceMethodList(ObjCProtocol Data) const override;
+  Expected<ObjCMethodList>
+  materializeOptionalClassMethodList(ObjCProtocol Data) const override;
+
+  // Override ObjC Property Implementation.
+  Expected<StringRef> getPropertyName(ObjCProperty Data) const override;
+  Expected<StringRef> getPropertyAttribute(ObjCProperty Data) const override;
+
+  // Override ObjC Method Implementation.
+  Expected<StringRef> getMethodName(ObjCMethod Data) const override;
+  Expected<StringRef> getMethodType(ObjCMethod Data) const override;
+
+  // Override ObjC Selector Ref Implementation.
+  Expected<ObjCSelectorList> referencedSelectors() const override;
+  Expected<StringRef> getObjCSelectorName(ObjCSelectorRef Ref) const override;
+
+  // Override Potentially defined selectors Implemetation.
+  void getAllPotentiallyDefinedSelectors(StringSet<> &Set) const override;
+
+  // Other.
+  StringRef getSymbolNameFromRef(ObjCRef Ref) const override;
+  StringRef guessClassNameBasedOnSymbol(StringRef Sym) const override;
+
+  const DataLayout &getDataLayout() const {
+    return OwningModule->getDataLayout();
+  }
+  Expected<ConstantStruct *> getObjC2ClassRO(ObjCClass Data) const;
+
+private:
+  Module *OwningModule;
+  bool Use64Bit;
+};
+
+} // namespace llvm
+
+#endif

llvm/include/llvm/Object/ObjCMetadata/ObjCMachOBinary.h

+//===- ObjCMachOBinary.h - ObjC MachO Metadata Interface --------*- C++ -*-===//
+//
+// 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 file declares ObjCMachOBinary interface.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJCMETADATA_OBJCMACHOBINARY_H
+#define LLVM_OBJCMETADATA_OBJCMACHOBINARY_H
+
+#include <llvm/Object/MachO.h>
+#include <llvm/Object/ObjCMetadata/ObjCMetadata.h>
+
+#include <unordered_map>
+
+namespace llvm {
+
+class MachOMetadata : public ObjCMetaDataReader {
+public:
+  MachOMetadata(object::MachOObjectFile *Binary, Error &Err);
+
+  object::MachOObjectFile *getMachOObject() {
+    return cast<object::MachOObjectFile>(OwningBinary);
+  }
+
+  bool isObjC1() const override { return ObjCVersion == ObjC1; }
+  bool isObjC2() const override { return ObjCVersion == ObjC2; }
+  Expected<StringRef> getSwiftVersion() const override;
+
+  const object::MachOObjectFile *getOwningBinary() const {
+    return OwningBinary;
+  }
+
+  // Overrides ObjC Class Ref Implementation.
+  Expected<ObjCClassList> classes() const override;
+  Expected<ObjCClass> getObjCClassFromRef(ObjCClassRef Ref) const override;
+  bool isObjCClassExternal(ObjCClassRef Ref) const override;
+
+  // Overrides ObjC Category Ref Implementation.
+  Expected<ObjCCategoryList> categories() const override;
+  Expected<ObjCCategory>
+  getObjCCategoryFromRef(ObjCCategoryRef Ref) const override;
+
+  // Overrides ObjC Protocol Ref Implementation.
+  Expected<ObjCProtocolList> protocols() const override;
+  Expected<ObjCProtocol>
+  getObjCProtocolFromRef(ObjCProtocolRef Ref) const override;
+
+  // Overrides ObjC Class Implementation.
+  Expected<StringRef> getObjCClassName(ObjCClass ClassRef) const override;
+  Expected<StringRef> getObjCSuperClassName(ObjCClass Data) const override;
+  Expected<bool> isObjCClassSwift(ObjCClass Data) const override;
+  Expected<bool> isObjCClassMetaClass(ObjCClass Data) const override;
+  Expected<ObjCPropertyList>
+  materializePropertyList(ObjCClass Data) const override;
+  Expected<ObjCPropertyList>
+  materializeClassPropertyList(ObjCClass Data) const override;
+  Expected<ObjCMethodList>
+  materializeInstanceMethodList(ObjCClass Data) const override;
+  Expected<ObjCMethodList>
+  materializeClassMethodList(ObjCClass Data) const override;
+
+  // Overrides ObjC Category Implementation.
+  Expected<StringRef> getObjCCategoryName(ObjCCategory Data) const override;
+  Expected<StringRef>
+  getObjCCategoryBaseClassName(ObjCCategory Data) const override;
+  Expected<ObjCPropertyList>
+  materializePropertyList(ObjCCategory Data) const override;
+  Expected<ObjCMethodList>
+  materializeInstanceMethodList(ObjCCategory Data) const override;
+  Expected<ObjCMethodList>
+  materializeClassMethodList(ObjCCategory Data) const override;
+
+  // Overrides ObjC Protocol Implementation.
+  Expected<StringRef> getObjCProtocolName(ObjCProtocol Data) const override;
+  Expected<ObjCPropertyList>
+  materializePropertyList(ObjCProtocol Data) const override;
+  Expected<ObjCMethodList>
+  materializeInstanceMethodList(ObjCProtocol Data) const override;
+  Expected<ObjCMethodList>
+  materializeClassMethodList(ObjCProtocol Data) const override;
+  Expected<ObjCMethodList>
+  materializeOptionalInstanceMethodList(ObjCProtocol Data) const override;
+  Expected<ObjCMethodList>
+  materializeOptionalClassMethodList(ObjCProtocol Data) const override;
+
+  // Override ObjC Property Implementation.
+  Expected<StringRef> getPropertyName(ObjCProperty Data) const override;
+  Expected<StringRef> getPropertyAttribute(ObjCProperty Data) const override;
+
+  // Override ObjC Method Implementation.
+  Expected<StringRef> getMethodName(ObjCMethod Data) const override;
+  Expected<StringRef> getMethodType(ObjCMethod Data) const override;
+
+  // Override ObjC Selector Ref Implementation.
+  Expected<ObjCSelectorList> referencedSelectors() const override;
+  Expected<StringRef> getObjCSelectorName(ObjCSelectorRef Ref) const override;
+
+  // Override Potentially defined selectors Implemetation.
+  void getAllPotentiallyDefinedSelectors(StringSet<> &Set) const override;
+
+  // Other.
+  StringRef getSymbolNameFromRef(ObjCRef Ref) const override;
+  StringRef guessClassNameBasedOnSymbol(StringRef Sym) const override;
+
+  // Helper classes
+  const object::SectionRef getSection(const char *segname,
+                                      const char *sectname) const;
+
+  Expected<StringRef> getValueFromAddress(uint64_t Address, uint64_t size,
+                                          bool objc_only = false) const;
+  Expected<StringRef> getStringFromAddress(uint64_t Address,
+                                           bool allowEmpty = false) const;
+  Expected<StringRef> getSymbolFromAddress(uint64_t Address, uint64_t &n_value,
+                                           uint64_t &addend,
+                                           uint64_t ReferenceValue = 0) const;
+  Expected<object::SectionRef> getSectionFromAddress(uint64_t Address) const;
+  bool isAddressEncrypted(uint64_t Address) const;
+  // Only available on pointer size.
+  Expected<uint64_t> getResolvedValueFromAddress64(uint64_t Address) const;
+  Expected<uint32_t> getResolvedValueFromAddress32(uint64_t Address) const;
+
+  // ObjC2 helper classes
+  Expected<ObjCRef> getObjC2ClassRO64(ObjCClass Data) const;
+  Expected<ObjCRef> getObjC2ClassRO32(ObjCClass Data) const;
+  Expected<ObjCClass> getObjC2MetaClass64(ObjCClass Data) const;
+  Expected<ObjCClass> getObjC2MetaClass32(ObjCClass Data) const;
+  // ObjC1 helper classes
+  Expected<ObjCRefList> getObjC1Modules() const;
+  Expected<ObjCRef> getObjC1Symtab(ObjCRef ObjCModule) const;
+  Expected<ObjCClassList> getObjC1ClassesFromSymtab(ObjCRef Symtab) const;
+  Expected<ObjCCategoryList> getObjC1CategoriesFromSymtab(ObjCRef Symtab) const;
+  Expected<ObjCMethodList> getObjC1MethodList(ObjCRef Methods) const;
+
+private:
+  object::MachOObjectFile *OwningBinary;
+  enum ObjCRuntimeVersion { Unknown = 0, ObjC1 = 1, ObjC2 = 2 };
+  ObjCRuntimeVersion ObjCVersion;
+  // Symbol lookup table.
+  // Map the address in the binary to the name of the symbol.
+  std::unordered_map<uint64_t, StringRef> AddressToSymbolMap;
+  std::unordered_map<uint64_t, object::RelocationRef> ExternalRelocMap;
+};
+
+} // namespace llvm
+
+#endif

llvm/include/llvm/Object/ObjCMetadata/ObjCMetadata.h

+//===- ObjCMetadata.h - Objective C Metadata Interface ----------*- C++ -*-===//
+//
+// 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 file declares ObjCMetadata Interfaces.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJCMETADATA_OBJCMETADATA_H
+#define LLVM_OBJCMETADATA_OBJCMETADATA_H
+
+#include <llvm/ADT/SmallVector.h>
+#include <llvm/ADT/StringRef.h>
+#include <llvm/ADT/StringSet.h>
+#include <llvm/IR/Constant.h>
+#include <llvm/Object/SymbolicFile.h>
+#include <llvm/Support/Error.h>
+#include <utility>
+
+namespace llvm {
+
+class ObjCRef {
+public:
+  uint64_t getValue() const { return v.a; }
+  void setValue(uint64_t value) { v.a = value; }
+
+  Constant *getLLVMConstant() const { return v.c; }
+  void setLLVMConstant(Constant *C) { v.c = C; }
+
+  int64_t getOffset() const { return offset; }
+  void setOffset(int64_t bytes) { offset = bytes; }
+
+  ObjCRef() { memset(&v, 0, sizeof(v)); }
+  ObjCRef(uint64_t value) : offset(0) { v.a = value; }
+  ObjCRef(Constant *C) : offset(0) { v.c = C; }
+  ObjCRef(Constant *C, int64_t offset) : offset(offset) { v.c = C; }
+
+  bool operator==(const ObjCRef &Other) const {
+    return std::memcmp(&v, &(Other.v), sizeof(v)) == 0;
+  }
+
+  bool operator!=(const ObjCRef &Other) const { return !(*this == Other); }
+
+private:
+  union {
+    uint64_t a;
+    Constant *c;
+  } v;
+  int64_t offset; // only used with v is Constant. FIXME: this is a hack.
+};
+
+class ObjCMetaDataReader;
+class ObjCClassRef;
+class ObjCProtocolRef;
+class ObjCCategoryRef;
+class ObjCMethod;
+class ObjCProperty;
+class ObjCSelectorRef;
+
+typedef SmallVector<ObjCRef, 2> ObjCRefList;
+typedef SmallVector<ObjCMethod, 2> ObjCMethodList;
+typedef SmallVector<ObjCProperty, 2> ObjCPropertyList;
+typedef SmallVector<ObjCClassRef, 2> ObjCClassList;
+typedef SmallVector<ObjCCategoryRef, 2> ObjCCategoryList;
+typedef SmallVector<ObjCProtocolRef, 2> ObjCProtocolList;
+typedef SmallVector<ObjCSelectorRef, 2> ObjCSelectorList;
+
+class ObjCInfoBase {
+public:
+  ObjCInfoBase(const ObjCMetaDataReader *Reader)
+      : Data(), MetadataReader(Reader) {}
+  ObjCInfoBase(const ObjCMetaDataReader *Reader, ObjCRef Data)
+      : Data(Data), MetadataReader(Reader) {}
+
+  bool operator==(const ObjCInfoBase &Other) const {
+    return Data == Other.Data;
+  }
+
+  ObjCRef &getRawContent() { return Data; }
+
+protected:
+  ObjCRef Data;
+  const ObjCMetaDataReader *MetadataReader;
+};
+
+class ObjCProperty : public ObjCInfoBase {
+public:
+  ObjCProperty(const ObjCMetaDataReader *Reader) : ObjCInfoBase(Reader) {}
+  ObjCProperty(const ObjCMetaDataReader *Reader, ObjCRef Data)
+      : ObjCInfoBase(Reader, Data) {}
+
+  Expected<StringRef> getName() const;
+  Expected<StringRef> getAttribute() const;
+  Expected<bool> isDynamic() const;
+
+  // Query for setter and getter.
+  // Return empty string if doesn't exists.
+  Expected<std::string> getGetter() const;
+  Expected<std::string> getSetter() const;
+};
+
+class ObjCMethod : public ObjCInfoBase {
+public:
+  ObjCMethod(const ObjCMetaDataReader *Reader) : ObjCInfoBase(Reader) {}
+  ObjCMethod(const ObjCMetaDataReader *Reader, ObjCRef Data)
+      : ObjCInfoBase(Reader, Data) {}
+
+  Expected<StringRef> getName() const;
+  Expected<StringRef> getType() const;
+};
+
+// Interface to read the ObjCClass.
+class ObjCClass : public ObjCInfoBase {
+public:
+  ObjCClass(const ObjCMetaDataReader *Reader) : ObjCInfoBase(Reader) {}
+  ObjCClass(const ObjCMetaDataReader *Reader, ObjCRef Data)
+      : ObjCInfoBase(Reader, Data) {}
+
+  Expected<StringRef> getName() const;
+  Expected<StringRef> getSuperClassName() const;
+
+  Expected<bool> isSwift() const;
+  Expected<bool> isMetaClass() const;
+
+  Expected<ObjCPropertyList> properties() const;
+  Expected<ObjCPropertyList> classProperties() const;
+  Expected<ObjCMethodList> instanceMethods() const;
+  Expected<ObjCMethodList> classMethods() const;
+};
+
+class ObjCCategory : public ObjCInfoBase {
+public:
+  ObjCCategory(const ObjCMetaDataReader *Reader) : ObjCInfoBase(Reader) {}
+  ObjCCategory(const ObjCMetaDataReader *Reader, ObjCRef Data)
+      : ObjCInfoBase(Reader, Data) {}
+
+  Expected<StringRef> getName() const;
+  Expected<StringRef> getBaseClassName() const;
+
+  Expected<ObjCPropertyList> properties() const;
+  Expected<ObjCMethodList> instanceMethods() const;
+  Expected<ObjCMethodList> classMethods() const;
+};
+
+class ObjCProtocol : public ObjCInfoBase {
+public:
+  ObjCProtocol(const ObjCMetaDataReader *Reader) : ObjCInfoBase(Reader) {}
+  ObjCProtocol(const ObjCMetaDataReader *Reader, ObjCRef Data)
+      : ObjCInfoBase(Reader, Data) {}
+
+  Expected<StringRef> getName() const;
+
+  Expected<ObjCPropertyList> properties() const;
+  Expected<ObjCMethodList> instanceMethods() const;
+  Expected<ObjCMethodList> classMethods() const;
+  Expected<ObjCMethodList> optionalInstanceMethods() const;
+  Expected<ObjCMethodList> optionalClassMethods() const;
+};
+
+class ObjCClassRef : public ObjCInfoBase {
+public:
+  ObjCClassRef(const ObjCMetaDataReader *Reader) : ObjCInfoBase(Reader) {}
+  ObjCClassRef(const ObjCMetaDataReader *Reader, ObjCRef Data)
+      : ObjCInfoBase(Reader, Data) {}
+
+  Expected<StringRef> getClassName() const;
+  bool isExternal() const;
+  Expected<ObjCClass> getObjCClass() const;
+  Expected<ObjCClass> operator*() const { return getObjCClass(); }
+};
+
+class ObjCCategoryRef : public ObjCInfoBase {
+public:
+  ObjCCategoryRef(const ObjCMetaDataReader *Reader) : ObjCInfoBase(Reader) {}
+  ObjCCategoryRef(const ObjCMetaDataReader *Reader, ObjCRef Data)
+      : ObjCInfoBase(Reader, Data) {}
+
+  Expected<ObjCCategory> getObjCCategory() const;
+  Expected<ObjCCategory> operator*() const { return getObjCCategory(); }
+};
+
+class ObjCProtocolRef : public ObjCInfoBase {
+public:
+  ObjCProtocolRef(const ObjCMetaDataReader *Reader) : ObjCInfoBase(Reader) {}
+  ObjCProtocolRef(const ObjCMetaDataReader *Reader, ObjCRef Data)
+      : ObjCInfoBase(Reader, Data) {}
+
+  Expected<ObjCProtocol> getObjCProtocol() const;
+  Expected<ObjCProtocol> operator*() const { return getObjCProtocol(); }
+};
+
+class ObjCSelectorRef : public ObjCInfoBase {
+public:
+  ObjCSelectorRef(const ObjCMetaDataReader *Reader) : ObjCInfoBase(Reader) {}
+  ObjCSelectorRef(const ObjCMetaDataReader *Reader, ObjCRef Data)
+      : ObjCInfoBase(Reader, Data) {}
+
+  Expected<StringRef> getSelector() const;
+};
+
+// ObjC Metadata Reader.
+class ObjCMetaDataReader {
+public:
+  virtual ~ObjCMetaDataReader() {}
+
+  // General
+  virtual bool isObjC1() const = 0;
+  virtual bool isObjC2() const = 0;
+
+  virtual Expected<StringRef> getSwiftVersion() const = 0;
+
+  // ObjCClassRef.
+  virtual Expected<ObjCClassList> classes() const = 0;
+  virtual Expected<ObjCClass> getObjCClassFromRef(ObjCClassRef Ref) const = 0;
+  virtual bool isObjCClassExternal(ObjCClassRef Ref) const = 0;
+
+  // ObjCCategoryRef.
+  virtual Expected<ObjCCategoryList> categories() const = 0;
+  virtual Expected<ObjCCategory>
+  getObjCCategoryFromRef(ObjCCategoryRef Ref) const = 0;
+
+  // ObjCProtocolRef.
+  virtual Expected<ObjCProtocolList> protocols() const = 0;
+  virtual Expected<ObjCProtocol>
+  getObjCProtocolFromRef(ObjCProtocolRef Ref) const = 0;
+
+  // ObjCClass.
+  virtual Expected<StringRef> getObjCClassName(ObjCClass Data) const = 0;
+  virtual Expected<StringRef> getObjCSuperClassName(ObjCClass Data) const = 0;
+  virtual Expected<bool> isObjCClassSwift(ObjCClass Data) const = 0;
+  virtual Expected<bool> isObjCClassMetaClass(ObjCClass Data) const = 0;
+  virtual Expected<ObjCPropertyList>
+  materializePropertyList(ObjCClass Data) const = 0;
+  virtual Expected<ObjCPropertyList>
+  materializeClassPropertyList(ObjCClass Data) const = 0;
+  virtual Expected<ObjCMethodList>
+  materializeInstanceMethodList(ObjCClass Data) const = 0;
+  virtual Expected<ObjCMethodList>
+  materializeClassMethodList(ObjCClass Data) const = 0;
+
+  // ObjCCategory.
+  virtual Expected<StringRef> getObjCCategoryName(ObjCCategory Data) const = 0;
+  virtual Expected<StringRef>
+  getObjCCategoryBaseClassName(ObjCCategory Data) const = 0;
+  virtual Expected<ObjCPropertyList>
+  materializePropertyList(ObjCCategory Data) const = 0;
+  virtual Expected<ObjCMethodList>
+  materializeInstanceMethodList(ObjCCategory Data) const = 0;
+  virtual Expected<ObjCMethodList>
+  materializeClassMethodList(ObjCCategory Data) const = 0;
+
+  // ObjCProtocol.
+  virtual Expected<StringRef> getObjCProtocolName(ObjCProtocol Data) const = 0;
+  virtual Expected<ObjCPropertyList>
+  materializePropertyList(ObjCProtocol Data) const = 0;
+  virtual Expected<ObjCMethodList>
+  materializeInstanceMethodList(ObjCProtocol Data) const = 0;
+  virtual Expected<ObjCMethodList>
+  materializeClassMethodList(ObjCProtocol Data) const = 0;
+  virtual Expected<ObjCMethodList>
+  materializeOptionalInstanceMethodList(ObjCProtocol Data) const = 0;
+  virtual Expected<ObjCMethodList>
+  materializeOptionalClassMethodList(ObjCProtocol Data) const = 0;
+
+  // ObjCProperty.
+  virtual Expected<StringRef> getPropertyName(ObjCProperty Data) const = 0;
+  virtual Expected<StringRef> getPropertyAttribute(ObjCProperty Data) const = 0;
+
+  // ObjCMethod.
+  virtual Expected<StringRef> getMethodName(ObjCMethod Data) const = 0;
+  virtual Expected<StringRef> getMethodType(ObjCMethod Data) const = 0;
+
+  // ObjCSelectorRef.
+  virtual Expected<ObjCSelectorList> referencedSelectors() const = 0;
+  virtual Expected<StringRef>
+  getObjCSelectorName(ObjCSelectorRef Ref) const = 0;
+
+  // Potentially defined selectors.
+  virtual void getAllPotentiallyDefinedSelectors(StringSet<> &Set) const = 0;
+
+  // Other.
+  virtual StringRef getSymbolNameFromRef(ObjCRef Ref) const = 0;
+  virtual StringRef guessClassNameBasedOnSymbol(StringRef Sym) const = 0;
+
+  // Helper.
+  Expected<StringRef> convertSwiftVersion(unsigned raw) const;
+};
+
+} // namespace llvm
+
+#endif

llvm/lib/Object/CMakeLists.txt

add_llvm_library(LLVMObject
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Object
 
   DEPENDS
   intrinsics_gen
   llvm_vcsrevision_h
   )
+
+add_subdirectory(ObjCMetadata)

llvm/lib/Object/ObjCMetadata/CMakeLists.txt

+add_llvm_library(LLVMObjCMetadata
+  ObjCBitcode.cpp
+  ObjCMetadata.cpp
+  ObjCMachOBinary.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${LLVM_MAIN_INCLUDE_DIR}/llvm/ObjCMetadata
+
+  DEPENDS
+  intrinsics_gen
+  )

llvm/lib/Object/ObjCMetadata/ObjCBitcode.cpp

+//===- ObjCBitcode.cpp - Bitcode ObjC Metadata Reader -----------*- C++ -*-===//
+//
+// 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 file defines the classes needed to parse ObjCMetadata in Bitcode.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Object/ObjCMetadata/ObjCBitcode.h"
+
+#include "macho-objc.h"
+
+#include "llvm/Analysis/InstructionSimplify.h"
+#include "llvm/Analysis/ValueTracking.h"
+#include "llvm/IR/Constant.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/GlobalAlias.h"
+#include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/Operator.h"
+#include "llvm/Object/Error.h"
+#include "llvm/Object/ObjCMetadata/ObjCMetadata.h"
+#include "llvm/Support/Error.h"
+
+using namespace llvm;
+using namespace object;
+
+static Value *getValueAtStructOffset(ConstantStruct *CS, uint64_t offset,
+                                     const DataLayout &DL) {
+  StructType *ST = CS->getType();
+  unsigned index = DL.getStructLayout(ST)->getElementContainingOffset(offset);
+  Value *Ret = CS->getOperand(index);
+  offset -= DL.getStructLayout(ST)->getElementOffset(index);
+  if (offset != 0) {
+    CS = dyn_cast<ConstantStruct>(Ret);
+    ST = CS->getType();
+    return getValueAtStructOffset(CS, offset, DL);
+  }
+  return Ret;
+}
+
+Value *getRealValue(Value *GV, const DataLayout &DL) {
+  int64_t offset = 0;
+  auto basePtr = dyn_cast<GlobalVariable>(
+      GetPointerBaseWithConstantOffset(GV, offset, DL));
+  if (!basePtr || !basePtr->hasInitializer()) {
+    return nullptr;
+  }
+  if (offset == 0)
+    return basePtr->getInitializer();
+  else if (auto CS = dyn_cast<ConstantStruct>(basePtr->getInitializer()))
+    return getValueAtStructOffset(CS, offset, DL);
+  else
+    return nullptr;
+}
+
+static User *getUserFromGlobal(Value *v) {
+  auto base_user = dyn_cast<User>(v);
+  assert(base_user && "Provided value is not a user!");
+  auto op0 = dyn_cast<User>(base_user->getOperand(0));
+  assert(op0 && "User doesn't have User operands!");
+  return op0;
+}
+
+// This is basically the GetUnderlyingObject in ValueTracking Analysis,
+// except it works through non-pointer types.
+static Value *GetUnderlyingValue(Value *V, const DataLayout &DL,
+                                 unsigned MaxLookup) {
+  for (unsigned Count = 0; MaxLookup == 0 || Count < MaxLookup; ++Count) {
+    if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
+      V = GEP->getPointerOperand();
+    } else if (Operator::getOpcode(V) == Instruction::BitCast ||
+               Operator::getOpcode(V) == Instruction::AddrSpaceCast) {
+      V = cast<Operator>(V)->getOperand(0);
+    } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
+      if (GA->isInterposable())
+        return V;
+      V = GA->getAliasee();
+    } else if (PtrToIntOperator *PTI = dyn_cast<PtrToIntOperator>(V)) {
+      V = PTI->getPointerOperand();
+    } else {
+      // See if InstructionSimplify knows any relevant tricks.
+      if (Instruction *I = dyn_cast<Instruction>(V))
+        // TODO: Acquire a DominatorTree and AssumptionCache and use them.
+        if (Value *Simplified = SimplifyInstruction(I, DL, nullptr)) {
+          V = Simplified;
+          continue;
+        }
+
+      return V;
+    }
+  }
+  return V;
+}
+
+// Check if a selector is actually defined with corresponding method,
+// even though it is not showing up when walking through the objc class
+// info. For example, this will find the selector defined in @objc swift
+// generic class.
+static bool hasUserInMethodList(const Value *V, const Module *M,
+                                unsigned maxDepth = 4) {
+  // Search through all the uses of the selector string to see if there are any
+  // usage in the __DATA,__objc_const section that looks like a method entry.
+  for (const auto &user : V->users()) {
+    if (auto *GV = dyn_cast<GlobalValue>(user)) {
+      if (GV->hasSection()) {
+        StringRef Section = GV->getSection();
+        std::string SectionName;
+        // Trim all spaces in the section name.
+        for (auto c : Section) {
+          if (c != ' ')
+            SectionName.push_back(c);
+        }
+        // Potential match of a method list.
+        // The method list should have type {i32, i32, [n x {i8*, i8*, i8*}]}.
+        if ((StringRef(SectionName).startswith("__DATA,__objc_const") ||
+             StringRef(SectionName).startswith("__DATA_CONST,__objc_const")) &&
+            V->getType()->isStructTy() &&
+            V->getType()->getStructNumElements() == 3 &&
+            V->getType()->getStructElementType(0)->isIntegerTy() &&
+            V->getType()->getStructElementType(1)->isIntegerTy() &&
+            V->getType()->getStructElementType(2)->isArrayTy())
+          return true;
+      }
+    }
+    // Recursively find method list.
+    if (maxDepth != 0 && hasUserInMethodList(user, M, maxDepth - 1))
+      return true;
+  }
+  return false;
+}
+
+// Get data from global variable. ConstantDataSequential might get padded and
+// move to special sections by ASAN. This function looks through ConstantStruct
+// and get underlying ConstantDataSequential.
+static Expected<StringRef> getStringRefFromGlobalVariable(User *Init) {
+  // Handle ConstantStruct first. That is from asan pass.
+  if (ConstantStruct *CS = dyn_cast<ConstantStruct>(Init)) {
+    Init = CS->getOperand(0);
+  }
+  if (ConstantDataSequential *CD = dyn_cast<ConstantDataSequential>(Init)) {
+    return CD->getAsString().rtrim('\0');
+  }
+  return make_error<StringError>("Cannot extract string from location",
+                                 object_error::parse_failed);
+}
+
+BitcodeMetadata::BitcodeMetadata(Module *M) : OwningModule(M) {
+  Triple TargetTriple(OwningModule->getTargetTriple());
+  Use64Bit =
+      TargetTriple.isArch64Bit() && (TargetTriple.getArchName() != "arm64_32");
+}
+
+Expected<ObjCClassList> BitcodeMetadata::classes() const {
+  ObjCClassList ClassList;
+  for (auto &GV : OwningModule->globals()) {
+    if (GV.hasSection() && GV.hasInitializer()) {
+      StringRef Section = GV.getSection();
+      std::string SectionName;
+      // Trim all spaces in the section name.
+      for (auto c : Section) {
+        if (c != ' ')
+          SectionName.push_back(c);
+      }
+      if (SectionName == "__DATA,__objc_classlist,regular,no_dead_strip" ||
+          SectionName ==
+              "__DATA_CONST,__objc_classlist,regular,no_dead_strip") {
+        auto structList = dyn_cast<Constant>(
+            GetUnderlyingObject(GV.getInitializer(), getDataLayout(), 2));
+        for (const auto &op : structList->operands())
+          ClassList.push_back(ObjCClassRef(this, cast<Constant>(&op)));
+      }
+    }
+  }
+
+  return ClassList;
+}
+
+Expected<ObjCClass>
+BitcodeMetadata::getObjCClassFromRef(ObjCClassRef Ref) const {
+  auto GV = Ref.getRawContent().getLLVMConstant();
+  int64_t class_offset = 0;
+  auto objc_class = dyn_cast<GlobalVariable>(
+      GetPointerBaseWithConstantOffset(GV, class_offset, getDataLayout()));
+  if (!objc_class)
+    return make_error<StringError>("Unable to find class associsated",
+                                   object_error::parse_failed);
+
+  return ObjCClass(this, {objc_class, class_offset});
+}
+
+bool BitcodeMetadata::isObjCClassExternal(ObjCClassRef Ref) const {
+  if (auto GV = cast<GlobalVariable>(Ref.getRawContent().getLLVMConstant())) {
+    if (GV->hasInitializer())
+      return false;
+  }
+  return true;
+}
+
+Expected<ObjCCategoryList> BitcodeMetadata::categories() const {
+  ObjCCategoryList CategoryList;
+  for (auto &GV : OwningModule->globals()) {
+    if (GV.hasSection() && GV.hasInitializer()) {
+      StringRef Section = GV.getSection();
+      std::string SectionName;
+      // Trim all spaces in the section name.
+      for (auto c : Section) {
+        if (c != ' ')
+          SectionName.push_back(c);
+      }
+      if (SectionName == "__DATA,__objc_catlist,regular,no_dead_strip" ||
+          SectionName == "__DATA_CONST,__objc_catlist,regular,no_dead_strip") {
+        auto structList = dyn_cast<Constant>(
+            GetUnderlyingObject(GV.getInitializer(), getDataLayout(), 2));
+        for (const auto &op : structList->operands())
+          CategoryList.push_back(ObjCCategoryRef(this, cast<Constant>(&op)));
+      }
+    }
+  }
+  return CategoryList;
+}
+
+Expected<ObjCCategory>
+BitcodeMetadata::getObjCCategoryFromRef(ObjCCategoryRef Ref) const {
+  auto GV = Ref.getRawContent().getLLVMConstant();
+  int64_t cat_offset = 0;
+  auto objc_category = dyn_cast<GlobalVariable>(
+      GetPointerBaseWithConstantOffset(GV, cat_offset, getDataLayout()));
+  if (!objc_category)
+    return make_error<StringError>("Unable to find category associsated",
+                                   object_error::parse_failed);
+
+  return ObjCCategory(this, {objc_category, cat_offset});
+}
+
+Expected<ObjCProtocolList> BitcodeMetadata::protocols() const {
+  ObjCProtocolList ProtocolList;
+  for (auto &GV : OwningModule->globals()) {
+    if (GV.hasSection() && GV.hasInitializer()) {
+      StringRef Section = GV.getSection();
+      std::string SectionName;
+      // Trim all spaces in the section name.
+      for (auto c : Section) {
+        if (c != ' ')
+          SectionName.push_back(c);
+      }
+      if (SectionName == "__DATA,__objc_protolist,coalesced,no_dead_strip" ||
+          SectionName ==
+              "__DATA_CONST,__objc_protolist,coalesced,no_dead_strip") {
+        ProtocolList.push_back(ObjCProtocolRef(this, &GV));
+      }
+    }
+  }
+  return ProtocolList;
+}
+
+Expected<ObjCProtocol>
+BitcodeMetadata::getObjCProtocolFromRef(ObjCProtocolRef Ref) const {
+  auto GV = cast<GlobalVariable>(Ref.getRawContent().getLLVMConstant());
+  auto protocol = dyn_cast<GlobalVariable>(
+      GetUnderlyingObject(GV->getInitializer(), getDataLayout(), 2));
+  if (!protocol)
+    return make_error<StringError>("Unable to find protocol associsated",
+                                   object_error::parse_failed);
+
+  return ObjCProtocol(this, protocol);
+}
+
+Expected<StringRef>
+BitcodeMetadata::getObjCClassName(ObjCClass ClassRef) const {
+  if (auto ro = getObjC2ClassRO(ClassRef)) {
+    unsigned offset =
+        Use64Bit ? offsetof(class_ro64_t, name) : offsetof(class_ro32_t, name);
+    auto class_name_global = dyn_cast<GlobalVariable>(GetUnderlyingObject(
+        getValueAtStructOffset(*ro, offset, getDataLayout()), getDataLayout(),
+        2));
+    if (!class_name_global)
+      return make_error<StringError>("Could not read ObjC class name",
+                                     object_error::parse_failed);
+    return getStringRefFromGlobalVariable(class_name_global->getInitializer());
+  } else
+    return ro.takeError();
+}
+
+Expected<StringRef>
+BitcodeMetadata::getObjCSuperClassName(ObjCClass Data) const {
+  auto objc_class =
+      cast<GlobalVariable>(Data.getRawContent().getLLVMConstant());
+  auto objc_class_t = cast<ConstantStruct>(
+      getUserFromGlobal(GetUnderlyingValue(objc_class, getDataLayout(), 2)));
+  int64_t class_offset = Data.getRawContent().getOffset();
+  // read class_ro
+  unsigned offset = Use64Bit ? offsetof(class64_t, superclass)
+                             : offsetof(class32_t, superclass);
+  auto superclass_t = getValueAtStructOffset(
+      objc_class_t, class_offset + offset, getDataLayout());
+  if (!isa<ConstantPointerNull>(superclass_t)) {
+    int64_t ClassOffset = 0;
+    if (auto superclass_global =
+            dyn_cast<GlobalVariable>(GetPointerBaseWithConstantOffset(
+                superclass_t, ClassOffset, getDataLayout()))) {
+      if (!superclass_global->hasInitializer())
+        return guessClassNameBasedOnSymbol(superclass_global->getName());
+      auto superclass = ObjCClass(this, {superclass_global, ClassOffset});
+      return superclass.getName();
+    } else
+      return make_error<StringError>("Cannot process superclass",
+                                     object_error::parse_failed);
+  }
+  return StringRef();
+}
+
+Expected<bool> BitcodeMetadata::isObjCClassSwift(ObjCClass Data) const {
+  ConstantStruct *objc_class_t = nullptr;
+  if (auto objc_class =
+          dyn_cast<GlobalVariable>(Data.getRawContent().getLLVMConstant())) {
+    objc_class_t = cast<ConstantStruct>(
+        getUserFromGlobal(GetUnderlyingValue(objc_class, getDataLayout(), 2)));
+  } else if (auto objc_class = dyn_cast<ConstantStruct>(
+                 Data.getRawContent().getLLVMConstant()))
+    objc_class_t = objc_class;
+  else
+    return make_error<StringError>("Unexpected type for objc class",
+                                   object_error::parse_failed);
+
+  int64_t class_offset = Data.getRawContent().getOffset();
+  // read class_ro
+  unsigned offset =
+      Use64Bit ? offsetof(class64_t, data) : offsetof(class32_t, data);
+  auto class_ro_v = getValueAtStructOffset(objc_class_t, class_offset + offset,
+                                           getDataLayout());
+  if (isa<ConstantExpr>(class_ro_v)) {
+    // swift generates class_ro with an offset using add constant expr
+    return true;
+  }
+  return false;
+}
+
+Expected<bool> BitcodeMetadata::isObjCClassMetaClass(ObjCClass Data) const {
+  if (auto ro = getObjC2ClassRO(Data)) {
+    unsigned offset = Use64Bit ? offsetof(class_ro64_t, flags)
+                               : offsetof(class_ro32_t, flags);
+    auto ClassFlag = dyn_cast<ConstantInt>(
+        GetUnderlyingValue(getValueAtStructOffset(*ro, offset, getDataLayout()),
+                           getDataLayout(), 2));
+    if (!ClassFlag)
+      return make_error<StringError>("Could not get flags from objc class",
+                                     object_error::parse_failed);
+    return ((ClassFlag->getZExtValue() & RO_META) != 0);
+  } else
+    return ro.takeError();
+}
+
+Expected<ObjCPropertyList>
+BitcodeMetadata::materializePropertyList(ObjCClass ClassRef) const {
+  ObjCPropertyList PropertyList;
+  if (auto ro = getObjC2ClassRO(ClassRef)) {
+    unsigned offset = Use64Bit ? offsetof(class_ro64_t, baseProperties)
+                               : offsetof(class_ro32_t, baseProperties);
+    auto objc_prop_list = dyn_cast<GlobalVariable>(
+        GetUnderlyingValue(getValueAtStructOffset(*ro, offset, getDataLayout()),
+                           getDataLayout(), 2));
+    if (objc_prop_list && objc_prop_list->hasInitializer()) {
+      auto property_list_t = getUserFromGlobal(objc_prop_list);
+      auto property_list = cast<Constant>(property_list_t->getOperand(2));
+      for (auto &op : property_list->operands())
+        PropertyList.push_back(ObjCProperty(this, cast<Constant>(&op)));
+    }
+    return PropertyList;
+  } else
+    return ro.takeError();
+}
+
+Expected<ObjCPropertyList>
+BitcodeMetadata::materializeClassPropertyList(ObjCClass ClassRef) const {
+  ConstantStruct *objc_class_t = nullptr;
+  if (auto objc_class = dyn_cast<GlobalVariable>(
+          ClassRef.getRawContent().getLLVMConstant())) {
+    objc_class_t = cast<ConstantStruct>(
+        getUserFromGlobal(GetUnderlyingValue(objc_class, getDataLayout(), 2)));
+  } else
+    return make_error<StringError>("Unexpected type for objc meta class",
+                                   object_error::parse_failed);
+
+  int64_t class_offset = ClassRef.getRawContent().getOffset();
+  auto metaclass = GetUnderlyingValue(
+      getValueAtStructOffset(objc_class_t, class_offset, getDataLayout()),
+      getDataLayout(), 2);
+  int64_t metaclass_offset = 0;
+  auto metaclass_g = dyn_cast<GlobalVariable>(GetPointerBaseWithConstantOffset(
+      metaclass, metaclass_offset, getDataLayout()));
+
+  if (!metaclass_g)
+    return make_error<StringError>("Unable to find meta class associsated",
+                                   object_error::parse_failed);
+
+  auto MetaClass = ObjCClass(this, {metaclass_g, metaclass_offset});
+  return materializePropertyList(MetaClass);
+}
+
+Expected<StringRef> BitcodeMetadata::getPropertyName(ObjCProperty Data) const {
+  auto NameVar = dyn_cast<GlobalVariable>(
+      GetUnderlyingValue(Data.getRawContent().getLLVMConstant()->getOperand(0),
+                         getDataLayout(), 2));
+  if (!NameVar)
+    return make_error<StringError>("Could not find property name",
+                                   object_error::parse_failed);
+
+  return getStringRefFromGlobalVariable(NameVar->getInitializer());
+}
+
+Expected<StringRef>
+BitcodeMetadata::getPropertyAttribute(ObjCProperty Data) const {
+  auto AttrVar = dyn_cast<GlobalVariable>(
+      GetUnderlyingValue(Data.getRawContent().getLLVMConstant()->getOperand(1),
+                         getDataLayout(), 2));
+  if (!AttrVar)
+    return make_error<StringError>("Could not find property attr",
+                                   object_error::parse_failed);
+
+  return getStringRefFromGlobalVariable(AttrVar->getInitializer());
+}
+
+Expected<ObjCMethodList>
+BitcodeMetadata::materializeInstanceMethodList(ObjCClass ClassRef) const {
+  ObjCMethodList MethodList;
+  if (auto ro = getObjC2ClassRO(ClassRef)) {
+    unsigned offset = Use64Bit ? offsetof(class_ro64_t, baseMethods)
+                               : offsetof(class_ro32_t, baseMethods);
+    auto objc_method_list = dyn_cast<User>(
+        GetUnderlyingValue(getValueAtStructOffset(*ro, offset, getDataLayout()),
+                           getDataLayout(), 2));
+    if (objc_method_list->getNumOperands() != 0) {
+      auto methList =
+          cast<User>(getUserFromGlobal(objc_method_list)->getOperand(2));
+      for (auto &op : methList->operands())
+        MethodList.push_back(ObjCMethod(this, cast<Constant>(&op)));
+    }
+    return MethodList;
+  } else
+    return ro.takeError();
+}
+
+Expected<ObjCMethodList>
+BitcodeMetadata::materializeClassMethodList(ObjCClass ClassRef) const {
+  ConstantStruct *objc_class_t = nullptr;
+  if (auto objc_class = dyn_cast<GlobalVariable>(
+          ClassRef.getRawContent().getLLVMConstant())) {
+    objc_class_t = cast<ConstantStruct>(
+        getUserFromGlobal(GetUnderlyingValue(objc_class, getDataLayout(), 2)));
+  } else
+    return make_error<StringError>("Unexpected type for objc meta class",
+                                   object_error::parse_failed);
+
+  int64_t class_offset = ClassRef.getRawContent().getOffset();
+  auto metaclass = GetUnderlyingValue(
+      getValueAtStructOffset(objc_class_t, class_offset, getDataLayout()),
+      getDataLayout(), 2);
+  int64_t metaclass_offset = 0;
+  auto metaclass_g = dyn_cast<GlobalVariable>(GetPointerBaseWithConstantOffset(
+      metaclass, metaclass_offset, getDataLayout()));
+
+  if (!metaclass_g)
+    return make_error<StringError>("Unable to find meta class associsated",
+                                   object_error::parse_failed);
+
+  auto MetaClass = ObjCClass(this, {metaclass_g, metaclass_offset});
+  return materializeInstanceMethodList(MetaClass);
+}
+
+Expected<StringRef>
+BitcodeMetadata::getObjCCategoryName(ObjCCategory Cat) const {
+  ConstantStruct *objc_cat_t = nullptr;
+  if (auto objc_category =
+          dyn_cast<GlobalVariable>(Cat.getRawContent().getLLVMConstant())) {
+    objc_cat_t = cast<ConstantStruct>(getUserFromGlobal(
+        GetUnderlyingValue(objc_category, getDataLayout(), 2)));
+  } else
+    return make_error<StringError>("Unexpected type for objc category",
+                                   object_error::parse_failed);
+
+  int64_t cat_offset = Cat.getRawContent().getOffset();
+  unsigned offset =
+      Use64Bit ? offsetof(category64_t, name) : offsetof(category32_t, name);
+  auto catname = dyn_cast<GlobalVariable>(GetUnderlyingObject(
+      getValueAtStructOffset(objc_cat_t, cat_offset + offset, getDataLayout()),
+      getDataLayout(), 2));
+  if (!catname)
+    return make_error<StringError>("Cannot extract catogery name",
+                                   object_error::parse_failed);
+
+  return getStringRefFromGlobalVariable(catname->getInitializer());
+}
+
+Expected<StringRef>
+BitcodeMetadata::getObjCCategoryBaseClassName(ObjCCategory Cat) const {
+  ConstantStruct *objc_cat_t = nullptr;
+  if (auto objc_category =
+          dyn_cast<GlobalVariable>(Cat.getRawContent().getLLVMConstant())) {
+    objc_cat_t = cast<ConstantStruct>(getUserFromGlobal(
+        GetUnderlyingValue(objc_category, getDataLayout(), 2)));
+  } else
+    return make_error<StringError>("Unexpected type for objc category",
+                                   object_error::parse_failed);
+
+  int64_t cat_offset = Cat.getRawContent().getOffset();
+  unsigned offset =
+      Use64Bit ? offsetof(category64_t, cls) : offsetof(category32_t, cls);
+  int64_t baseclass_offset = 0;
+  auto baseCls = dyn_cast<GlobalVariable>(GetPointerBaseWithConstantOffset(
+      getValueAtStructOffset(objc_cat_t, cat_offset + offset, getDataLayout()),
+      baseclass_offset, getDataLayout()));
+  if (!baseCls)
+    return make_error<StringError>("Cannot extract category base class",
+                                   object_error::parse_failed);
+  if (!baseCls->hasInitializer())
+    return guessClassNameBasedOnSymbol(baseCls->getName());
+  auto baseClsRef = ObjCClass(this, {baseCls, baseclass_offset});
+  return baseClsRef.getName();
+}
+
+Expected<ObjCPropertyList>
+BitcodeMetadata::materializePropertyList(ObjCCategory Cat) const {
+  ConstantStruct *objc_cat_t = nullptr;
+  if (auto objc_category =
+          dyn_cast<GlobalVariable>(Cat.getRawContent().getLLVMConstant())) {
+    objc_cat_t = cast<ConstantStruct>(getUserFromGlobal(
+        GetUnderlyingValue(objc_category, getDataLayout(), 2)));
+  } else
+    return make_error<StringError>("Unexpected type for objc category",
+                                   object_error::parse_failed);
+
+  ObjCPropertyList PropertyList;
+  int64_t cat_offset = Cat.getRawContent().getOffset();
+  unsigned offset = Use64Bit ? offsetof(category64_t, instanceProperties)
+                             : offsetof(category32_t, instanceProperties);
+  auto props = dyn_cast<GlobalVariable>(GetUnderlyingObject(
+      getValueAtStructOffset(objc_cat_t, cat_offset + offset, getDataLayout()),
+      getDataLayout(), 2));
+
+  if (props && props->hasInitializer()) {
+    auto property_list_t = getUserFromGlobal(props);
+    auto property_list = cast<Constant>(property_list_t->getOperand(2));
+    for (auto &op : property_list->operands())
+      PropertyList.push_back(ObjCProperty(this, cast<Constant>(&op)));
+  }
+  return PropertyList;
+}
+
+Expected<ObjCMethodList>
+BitcodeMetadata::materializeInstanceMethodList(ObjCCategory Cat) const {
+  ConstantStruct *objc_cat_t = nullptr;
+  if (auto objc_category =
+          dyn_cast<GlobalVariable>(Cat.getRawContent().getLLVMConstant())) {
+    objc_cat_t = cast<ConstantStruct>(getUserFromGlobal(
+        GetUnderlyingValue(objc_category, getDataLayout(), 2)));
+  } else
+    return make_error<StringError>("Unexpected type for objc category",
+                                   object_error::parse_failed);
+
+  ObjCMethodList MethodList;
+  int64_t cat_offset = Cat.getRawContent().getOffset();
+  unsigned offset = Use64Bit ? offsetof(category64_t, instanceMethods)
+                             : offsetof(category32_t, instanceMethods);
+  auto method_list_global = dyn_cast<User>(GetUnderlyingObject(
+      getValueAtStructOffset(objc_cat_t, cat_offset + offset, getDataLayout()),
+      getDataLayout(), 2));
+  if (method_list_global->getNumOperands() != 0) {
+    auto methList =
+        dyn_cast<User>(getUserFromGlobal(method_list_global)->getOperand(2));
+    for (auto &op : methList->operands())
+      MethodList.push_back(ObjCMethod(this, cast<Constant>(&op)));
+  }
+  return MethodList;
+}
+
+Expected<ObjCMethodList>
+BitcodeMetadata::materializeClassMethodList(ObjCCategory Cat) const {
+  ConstantStruct *objc_cat_t = nullptr;
+  if (auto objc_category =
+          dyn_cast<GlobalVariable>(Cat.getRawContent().getLLVMConstant())) {
+    objc_cat_t = cast<ConstantStruct>(getUserFromGlobal(
+        GetUnderlyingValue(objc_category, getDataLayout(), 2)));
+  } else
+    return make_error<StringError>("Unexpected type for objc category",
+                                   object_error::parse_failed);
+
+  ObjCMethodList MethodList;
+  int64_t cat_offset = Cat.getRawContent().getOffset();
+  unsigned offset = Use64Bit ? offsetof(category64_t, classMethods)
+                             : offsetof(category32_t, classMethods);
+  auto method_list_global = dyn_cast<User>(GetUnderlyingObject(
+      getValueAtStructOffset(objc_cat_t, cat_offset + offset, getDataLayout()),
+      getDataLayout(), 2));
+  if (method_list_global->getNumOperands() != 0) {
+    auto methList =
+        dyn_cast<User>(getUserFromGlobal(method_list_global)->getOperand(2));
+    for (auto &op : methList->operands())
+      MethodList.push_back(ObjCMethod(this, cast<Constant>(&op)));
+  }
+  return MethodList;
+}
+
+Expected<StringRef>
+BitcodeMetadata::getObjCProtocolName(ObjCProtocol Data) const {
+  auto *objc_proto_t =
+      cast<ConstantStruct>(getUserFromGlobal(GetUnderlyingValue(
+          Data.getRawContent().getLLVMConstant(), getDataLayout(), 2)));
+  if (!objc_proto_t)
+    return make_error<StringError>("Unexpected type for objc protocol",
+                                   object_error::parse_failed);
+
+  unsigned offset =
+      Use64Bit ? offsetof(protocol64_t, name) : offsetof(protocol32_t, name);
+  auto protoName = dyn_cast<GlobalVariable>(GetUnderlyingObject(
+      getValueAtStructOffset(objc_proto_t, offset, getDataLayout()),
+      getDataLayout(), 2));
+  if (!protoName)
+    return make_error<StringError>("Cannot extract protocol name",
+                                   object_error::parse_failed);
+
+  return getStringRefFromGlobalVariable(protoName->getInitializer());
+}
+
+Expected<ObjCPropertyList>
+BitcodeMetadata::materializePropertyList(ObjCProtocol Data) const {
+  auto *objc_proto_t =
+      cast<ConstantStruct>(getUserFromGlobal(GetUnderlyingValue(
+          Data.getRawContent().getLLVMConstant(), getDataLayout(), 2)));
+  if (!objc_proto_t)
+    return make_error<StringError>("Unexpected type for objc protocol",
+                                   object_error::parse_failed);
+
+  unsigned offset = Use64Bit ? offsetof(protocol64_t, instanceProperties)
+                             : offsetof(protocol32_t, instanceProperties);
+
+  ObjCPropertyList PropertyList;
+  auto props = dyn_cast<GlobalVariable>(GetUnderlyingObject(
+      getValueAtStructOffset(objc_proto_t, offset, getDataLayout()),
+      getDataLayout(), 2));
+
+  if (props && props->hasInitializer()) {
+    auto property_list_t = getUserFromGlobal(props);
+    auto property_list = cast<Constant>(property_list_t->getOperand(2));
+    for (auto &op : property_list->operands())
+      PropertyList.push_back(ObjCProperty(this, cast<Constant>(&op)));
+  }
+  return PropertyList;
+}
+
+Expected<ObjCMethodList>
+BitcodeMetadata::materializeInstanceMethodList(ObjCProtocol Data) const {
+  auto *objc_proto_t =
+      cast<ConstantStruct>(getUserFromGlobal(GetUnderlyingValue(
+          Data.getRawContent().getLLVMConstant(), getDataLayout(), 2)));
+  if (!objc_proto_t)
+    return make_error<StringError>("Unexpected type for objc protocol",
+                                   object_error::parse_failed);
+
+  unsigned offset = Use64Bit ? offsetof(protocol64_t, instanceMethods)
+                             : offsetof(protocol32_t, instanceMethods);
+
+  ObjCMethodList MethodList;
+  auto method_list_global = dyn_cast<User>(GetUnderlyingObject(
+      getValueAtStructOffset(objc_proto_t, offset, getDataLayout()),
+      getDataLayout(), 2));
+  if (method_list_global->getNumOperands() != 0) {
+    auto methList =
+        dyn_cast<User>(getUserFromGlobal(method_list_global)->getOperand(2));
+    for (auto &op : methList->operands())
+      MethodList.push_back(ObjCMethod(this, cast<Constant>(&op)));
+  }
+  return MethodList;
+}
+
+Expected<ObjCMethodList>
+BitcodeMetadata::materializeClassMethodList(ObjCProtocol Data) const {
+  auto *objc_proto_t =
+      cast<ConstantStruct>(getUserFromGlobal(GetUnderlyingValue(
+          Data.getRawContent().getLLVMConstant(), getDataLayout(), 2)));
+  if (!objc_proto_t)
+    return make_error<StringError>("Unexpected type for objc protocol",
+                                   object_error::parse_failed);
+
+  unsigned offset = Use64Bit ? offsetof(protocol64_t, classMethods)
+                             : offsetof(protocol32_t, classMethods);
+
+  ObjCMethodList MethodList;
+  auto method_list_global = dyn_cast<User>(GetUnderlyingObject(
+      getValueAtStructOffset(objc_proto_t, offset, getDataLayout()),
+      getDataLayout(), 2));
+  if (method_list_global->getNumOperands() != 0) {
+    auto methList =
+        dyn_cast<User>(getUserFromGlobal(method_list_global)->getOperand(2));
+    for (auto &op : methList->operands())
+      MethodList.push_back(ObjCMethod(this, cast<Constant>(&op)));
+  }
+  return MethodList;
+}
+
+Expected<ObjCMethodList> BitcodeMetadata::materializeOptionalInstanceMethodList(
+    ObjCProtocol Data) const {
+  auto *objc_proto_t =
+      cast<ConstantStruct>(getUserFromGlobal(GetUnderlyingValue(
+          Data.getRawContent().getLLVMConstant(), getDataLayout(), 2)));
+  if (!objc_proto_t)
+    return make_error<StringError>("Unexpected type for objc protocol",
+                                   object_error::parse_failed);
+
+  unsigned offset = Use64Bit ? offsetof(protocol64_t, optionalInstanceMethods)
+                             : offsetof(protocol32_t, optionalInstanceMethods);
+
+  ObjCMethodList MethodList;
+  auto method_list_global = dyn_cast<User>(GetUnderlyingObject(
+      getValueAtStructOffset(objc_proto_t, offset, getDataLayout()),
+      getDataLayout(), 2));
+  if (method_list_global->getNumOperands() != 0) {
+    auto methList =
+        dyn_cast<User>(getUserFromGlobal(method_list_global)->getOperand(2));
+    for (auto &op : methList->operands())
+      MethodList.push_back(ObjCMethod(this, cast<Constant>(&op)));
+  }
+  return MethodList;
+}
+
+Expected<ObjCMethodList>
+BitcodeMetadata::materializeOptionalClassMethodList(ObjCProtocol Data) const {
+  auto *objc_proto_t =
+      cast<ConstantStruct>(getUserFromGlobal(GetUnderlyingValue(
+          Data.getRawContent().getLLVMConstant(), getDataLayout(), 2)));
+  if (!objc_proto_t)
+    return make_error<StringError>("Unexpected type for objc protocol",
+                                   object_error::parse_failed);
+
+  unsigned offset = Use64Bit ? offsetof(protocol64_t, optionalClassMethods)
+                             : offsetof(protocol32_t, optionalClassMethods);
+
+  ObjCMethodList MethodList;
+  auto method_list_global = dyn_cast<User>(GetUnderlyingObject(
+      getValueAtStructOffset(objc_proto_t, offset, getDataLayout()),
+      getDataLayout(), 2));
+  if (method_list_global->getNumOperands() != 0) {
+    auto methList =
+        dyn_cast<User>(getUserFromGlobal(method_list_global)->getOperand(2));
+    for (auto &op : methList->operands())
+      MethodList.push_back(ObjCMethod(this, cast<Constant>(&op)));
+  }
+  return MethodList;
+}
+
+Expected<StringRef> BitcodeMetadata::getMethodName(ObjCMethod Data) const {
+  auto objcMeth = Data.getRawContent().getLLVMConstant();
+  auto NameVar = dyn_cast<GlobalVariable>(
+      GetUnderlyingObject(objcMeth->getOperand(0), getDataLayout(), 2));
+  if (!NameVar)
+    return make_error<StringError>("Could not find property name",
+                                   object_error::parse_failed);
+
+  return getStringRefFromGlobalVariable(NameVar->getInitializer());
+}
+
+Expected<StringRef> BitcodeMetadata::getMethodType(ObjCMethod Data) const {
+  auto objcMeth = Data.getRawContent().getLLVMConstant();
+  auto TypeVar = dyn_cast<GlobalVariable>(
+      GetUnderlyingObject(objcMeth->getOperand(1), getDataLayout(), 2));
+  if (!TypeVar)
+    return make_error<StringError>("Could not find property name",
+                                   object_error::parse_failed);
+
+  return getStringRefFromGlobalVariable(TypeVar->getInitializer());
+}
+
+Expected<ObjCSelectorList> BitcodeMetadata::referencedSelectors() const {
+  ObjCSelectorList SelectorList;
+  for (auto &GV : OwningModule->globals()) {
+    if (GV.hasSection()) {
+      StringRef Section = GV.getSection();
+      std::string SectionName;
+      // Trim all spaces in the section name.
+      for (auto c : Section) {
+        if (c != ' ')
+          SectionName.push_back(c);
+      }
+      if (SectionName ==
+          "__DATA,__objc_selrefs,literal_pointers,no_dead_strip") {
+        SelectorList.push_back(ObjCSelectorRef(this, &GV));
+      }
+    }
+  }
+  return SelectorList;
+}
+
+Expected<StringRef>
+BitcodeMetadata::getObjCSelectorName(ObjCSelectorRef Ref) const {
+  auto GV = dyn_cast<GlobalVariable>(Ref.getRawContent().getLLVMConstant());
+  auto sel_global =
+      GetUnderlyingObject(GV->getInitializer(), getDataLayout(), 2);
+  return getStringRefFromGlobalVariable(getUserFromGlobal(sel_global));
+}
+
+// This is a workaround for swift generics @objc classes which swift compiler
+// doesn't emit complete objc metadata during compile time.
+// api-analyzer need to walk the selector reference to figure out if the
+// selector name is used in some data struct looks like a objc_method in
+// __objc_const section.
+// Note: bitcode api-analyzer returns less results because bitcode is prelinked
+// and the llvm uselist doesn't return uses across modules.
+void BitcodeMetadata::getAllPotentiallyDefinedSelectors(
+    StringSet<> &Set) const {
+  auto ignoreError = [](Error &&E) {
+    handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
+      return; // ignore.
+    });
+  };
+  if (auto selectors = referencedSelectors()) {
+    for (auto &sel : *selectors) {
+      auto GV = dyn_cast<GlobalVariable>(sel.getRawContent().getLLVMConstant());
+      if (!GV->hasInitializer())
+        continue;
+      auto sel_global =
+          GetUnderlyingObject(GV->getInitializer(), getDataLayout(), 2);
+      if (hasUserInMethodList(sel_global, OwningModule)) {
+        if (auto name = sel.getSelector())
+          Set.insert(*name);
+        else
+          ignoreError(name.takeError());
+      }
+    }
+  } else
+    ignoreError(selectors.takeError());
+}
+
+bool BitcodeMetadata::isObjC1() const {
+  auto versionMD = OwningModule->getModuleFlag("Objective-C Version");
+  if (versionMD) {
+    auto objcVer =
+        cast<ConstantInt>(cast<ConstantAsMetadata>(versionMD)->getValue())
+            ->getZExtValue();
+    if (objcVer == 1)
+      return true;
+  }
+  return false;
+}
+
+bool BitcodeMetadata::isObjC2() const {
+  auto versionMD = OwningModule->getModuleFlag("Objective-C Version");
+  if (versionMD) {
+    auto objcVer =
+        cast<ConstantInt>(cast<ConstantAsMetadata>(versionMD)->getValue())
+            ->getZExtValue();
+    if (objcVer == 2)
+      return true;
+  }
+  return false;
+}
+
+Expected<StringRef> BitcodeMetadata::getSwiftVersion() const {
+  auto versionMD = OwningModule->getModuleFlag("Swift Version");
+  if (!versionMD)
+    return "";
+  auto SwiftVersion =
+      cast<ConstantInt>(cast<ConstantAsMetadata>(versionMD)->getValue())
+          ->getZExtValue();
+
+  return convertSwiftVersion(SwiftVersion);
+}
+
+Expected<ConstantStruct *>
+BitcodeMetadata::getObjC2ClassRO(ObjCClass Data) const {
+  ConstantStruct *objc_class_t = nullptr;
+  if (auto objc_class =
+          dyn_cast<GlobalVariable>(Data.getRawContent().getLLVMConstant())) {
+    objc_class_t = cast<ConstantStruct>(
+        getUserFromGlobal(GetUnderlyingValue(objc_class, getDataLayout(), 2)));
+  } else
+    return make_error<StringError>("Unexpected type for objc class",
+                                   object_error::parse_failed);
+
+  int64_t class_offset = Data.getRawContent().getOffset();
+  // read class_ro
+  unsigned offset =
+      Use64Bit ? offsetof(class64_t, data) : offsetof(class32_t, data);
+  auto class_ro_v = getValueAtStructOffset(objc_class_t, class_offset + offset,
+                                           getDataLayout());
+  if (auto CE = dyn_cast<ConstantExpr>(class_ro_v)) {
+    // swift generates class_ro with an offset using add constant expr
+    class_ro_v = CE->getOperand(0);
+  }
+  auto class_ro_global = dyn_cast<GlobalVariable>(
+      GetUnderlyingValue(class_ro_v, getDataLayout(), 2));
+  if (!class_ro_global)
+    return make_error<StringError>("Could not read ObjCClass RO data",
+                                   object_error::parse_failed);
+  auto class_ro = dyn_cast<ConstantStruct>(getUserFromGlobal(
+      GetUnderlyingValue(class_ro_global, getDataLayout(), 4)));
+  if (!class_ro)
+    return make_error<StringError>("Could not process ObjCClass RO data",
+                                   object_error::parse_failed);
+  return class_ro;
+}
+
+StringRef BitcodeMetadata::getSymbolNameFromRef(ObjCRef Ref) const {
+  return Ref.getLLVMConstant()->getName();
+}
+
+StringRef BitcodeMetadata::guessClassNameBasedOnSymbol(StringRef Sym) const {
+  if (Sym.startswith("OBJC_CLASS_$_"))
+    return Sym.drop_front(strlen("OBJC_CLASS_$_"));
+  else if (Sym.startswith("\01.objc_class_name_"))
+    return Sym.drop_front(strlen("\01.objc_class_name_"));
+  else
+    return Sym;
+}

llvm/lib/Object/ObjCMetadata/ObjCMachOBinary.cpp

+//===- ObjCMachOBinary.cpp - Mach-O ObjC Metadata Reader --------*- C++ -*-===//
+//
+// 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 file defines the classes needed to parse ObjCMetadata in MachO Object.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Object/ObjCMetadata/ObjCMachOBinary.h"
+#include "macho-objc.h"
+
+#include "llvm/Object/Error.h"
+#include "llvm/Object/MachO.h"
+#include "llvm/Object/ObjCMetadata/ObjCMetadata.h"
+
+using namespace llvm;
+using namespace object;
+
+static Error unsupportedObjCRuntimeError() {
+  return make_error<StringError>("Unsupported ObjC Runtime",
+                                 object_error::parse_failed);
+}
+
+MachOMetadata::MachOMetadata(object::MachOObjectFile *Binary, Error &Err)
+    : OwningBinary(Binary) {
+  // Identify ObjC Version.
+  if (getSection("__OBJC", "__module_info") != SectionRef() &&
+      !OwningBinary->is64Bit())
+    ObjCVersion = ObjC1;
+  else if ((getSection("__OBJC2", "__module_info") != SectionRef()) ||
+           (getSection("__DATA_CONST", "__objc_imageinfo") != SectionRef()) ||
+           (getSection("__DATA", "__objc_imageinfo") != SectionRef()))
+    ObjCVersion = ObjC2;
+  else
+    ObjCVersion = Unknown;
+
+  // Build Address to symbol name lookup.
+  struct SectionInfo {
+    uint64_t Address;
+    uint64_t Size;
+    uint64_t OffsetInSegment;
+    uint64_t SegmentStartAddress;
+    uint32_t SegmentIndex;
+  };
+  SmallVector<SectionInfo, 32> Sections;
+  uint32_t CurSegIndex = Binary->hasPageZeroSegment() ? 1 : 0;
+  StringRef CurSegName;
+  uint64_t CurSegAddress;
+  for (const SectionRef &Section : Binary->sections()) {
+    SectionInfo Info;
+    Info.Address = Section.getAddress();
+    Info.Size = Section.getSize();
+    StringRef SegmentName =
+        Binary->getSectionFinalSegmentName(Section.getRawDataRefImpl());
+    if (!SegmentName.equals(CurSegName)) {
+      ++CurSegIndex;
+      CurSegName = SegmentName;
+      CurSegAddress = Info.Address;
+    }
+    Info.SegmentIndex = CurSegIndex - 1;
+    Info.OffsetInSegment = Info.Address - CurSegAddress;
+    Info.SegmentStartAddress = CurSegAddress;
+    Sections.push_back(Info);
+  }
+
+  // Cache address to symbol map.
+  for (const auto &Entry : OwningBinary->bindTable(Err)) {
+    uint64_t Addr = Entry.address();
+    if (Addr != 0)
+      AddressToSymbolMap.emplace(Addr, Entry.symbolName());
+  }
+
+  // cache all external relocations.
+  for (const auto &S : Binary->sections()) {
+    for (const auto &Reloc : S.relocations()) {
+      uint64_t Address = S.getAddress() + Reloc.getOffset();
+      auto Rel = Reloc.getRawDataRefImpl();
+      auto RE = Binary->getRelocation(Rel);
+      if (Binary->isRelocationScattered(RE))
+        continue;
+      if (Binary->getPlainRelocationExternal(RE))
+        ExternalRelocMap.emplace(Address, Reloc);
+    }
+  }
+}
+
+Expected<ObjCClassList> MachOMetadata::classes() const {
+  ObjCClassList ClassList;
+  if (isObjC2()) {
+    SectionRef ClassSect = getSection("__DATA_CONST", "__objc_classlist");
+    if (ClassSect == SectionRef())
+      ClassSect = getSection("__DATA", "__objc_classlist");
+    if (ClassSect == SectionRef())
+      ClassSect = getSection("__OBJC2", "__class_list");
+    // Return empty if the section doesn't exists.
+    if (ClassSect == SectionRef())
+      return ClassList;
+    if (ClassSect.getSize() % OwningBinary->getBytesInAddress() != 0)
+      return make_error<StringError>(
+          "objc class section size is not a multiple of pointer size",
+          object_error::parse_failed);
+
+    for (unsigned i = 0; i < ClassSect.getSize();
+         i += OwningBinary->getBytesInAddress())
+      ClassList.push_back(ObjCClassRef(this, ClassSect.getAddress() + i));
+  } else if (isObjC1()) {
+    auto ObjCModules = getObjC1Modules();
+    if (!ObjCModules)
+      return ObjCModules.takeError();
+    for (auto &M : *ObjCModules) {
+      auto sym = getObjC1Symtab(M);
+      if (!sym)
+        return sym.takeError();
+      // Handle empty symtab.
+      if (sym->getValue() == 0)
+        continue;
+      if (auto cls = getObjC1ClassesFromSymtab(*sym))
+        ClassList.append(cls->begin(), cls->end());
+      else
+        return cls.takeError();
+    }
+  }
+
+  return ClassList;
+}
+
+Expected<ObjCClass> MachOMetadata::getObjCClassFromRef(ObjCClassRef Ref) const {
+  if (OwningBinary->is64Bit()) {
+    if (auto class_ptr =
+            getResolvedValueFromAddress64(Ref.getRawContent().getValue()))
+      return ObjCClass(this, *class_ptr);
+    else
+      return class_ptr.takeError();
+  } else {
+    if (auto class_ptr =
+            getResolvedValueFromAddress32(Ref.getRawContent().getValue()))
+      return ObjCClass(this, *class_ptr);
+    else
+      return class_ptr.takeError();
+  }
+}
+
+bool MachOMetadata::isObjCClassExternal(ObjCClassRef Ref) const {
+  // If there are external relocations or external symbols at the address,
+  // return true;
+  if (AddressToSymbolMap.count(Ref.getRawContent().getValue()) ||
+      ExternalRelocMap.count(Ref.getRawContent().getValue()))
+    return true;
+
+  // Otherwise, check value 0.
+  if (OwningBinary->is64Bit()) {
+    if (auto addr =
+            getResolvedValueFromAddress64(Ref.getRawContent().getValue())) {
+      if (*addr == 0)
+        return true;
+      else
+        return false;
+    } else {
+      // assume external if can't get class.
+      // ignore error and return true.
+      handleAllErrors(addr.takeError(),
+                      [&](const ErrorInfoBase &EI) { return; });
+      return true;
+    }
+  } else {
+    if (auto addr =
+            getResolvedValueFromAddress32(Ref.getRawContent().getValue())) {
+      if (*addr == 0)
+        return true;
+      else
+        return false;
+    } else {
+      // assume external if can't get class.
+      // ignore error and return true.
+      handleAllErrors(addr.takeError(),
+                      [&](const ErrorInfoBase &EI) { return; });
+      return true;
+    }
+  }
+}
+
+StringRef MachOMetadata::getSymbolNameFromRef(ObjCRef Ref) const {
+  uint64_t offset, addend;
+  if (auto symName = getSymbolFromAddress(Ref.getValue(), offset, addend))
+    return *symName;
+  else {
+    // ignore error and return empty string.
+    handleAllErrors(symName.takeError(),
+                    [&](const ErrorInfoBase &EI) { return; });
+    return StringRef();
+  }
+}
+
+StringRef MachOMetadata::guessClassNameBasedOnSymbol(StringRef Sym) const {
+  if (Sym.startswith("_OBJC_CLASS_$_"))
+    return Sym.drop_front(strlen("_OBJC_CLASS_$_"));
+  else if (Sym.startswith(".objc_class_name_"))
+    return Sym.drop_front(strlen(".objc_class_name_"));
+  else
+    return Sym;
+}
+
+Expected<ObjCCategoryList> MachOMetadata::categories() const {
+  ObjCCategoryList CategoryList;
+  if (isObjC2()) {
+    SectionRef CatSect = getSection("__DATA_CONST", "__objc_catlist");
+    if (CatSect == SectionRef())
+      CatSect = getSection("__DATA", "__objc_catlist");
+    if (CatSect == SectionRef())
+      CatSect = getSection("__OBJC2", "__category_list");
+    // Return empty if the section doesn't exists.
+    if (CatSect == SectionRef())
+      return CategoryList;
+    if (CatSect.getSize() % OwningBinary->getBytesInAddress() != 0)
+      return make_error<StringError>(
+          "objc category section size is not a multiple of pointer size",
+          object_error::parse_failed);
+
+    for (unsigned i = 0; i < CatSect.getSize();
+         i += OwningBinary->getBytesInAddress())
+      CategoryList.push_back(ObjCCategoryRef(this, CatSect.getAddress() + i));
+  } else if (isObjC1()) {
+    auto ObjCModules = getObjC1Modules();
+    if (!ObjCModules)
+      return ObjCModules.takeError();
+    for (auto &M : *ObjCModules) {
+      auto sym = getObjC1Symtab(M);
+      if (!sym)
+        return sym.takeError();
+      // Handle empty symtab.
+      if (sym->getValue() == 0)
+        continue;
+      if (auto cat = getObjC1CategoriesFromSymtab(*sym))
+        CategoryList.append(cat->begin(), cat->end());
+      else
+        return cat.takeError();
+    }
+  }
+
+  return CategoryList;
+}
+
+Expected<ObjCCategory>
+MachOMetadata::getObjCCategoryFromRef(ObjCCategoryRef Ref) const {
+  if (OwningBinary->is64Bit()) {
+    if (auto cat_ptr =
+            getResolvedValueFromAddress64(Ref.getRawContent().getValue()))
+      return ObjCCategory(this, *cat_ptr);
+    else
+      return cat_ptr.takeError();
+  } else {
+    if (auto cat_ptr =
+            getResolvedValueFromAddress32(Ref.getRawContent().getValue()))
+      return ObjCCategory(this, *cat_ptr);
+    else
+      return cat_ptr.takeError();
+  }
+}
+
+Expected<ObjCProtocolList> MachOMetadata::protocols() const {
+  ObjCProtocolList ProtocolList;
+  if (isObjC2()) {
+    SectionRef ProtoSect = getSection("__DATA_CONST", "__objc_protolist");
+    if (ProtoSect == SectionRef())
+      ProtoSect = getSection("__DATA", "__objc_protolist");
+    if (ProtoSect == SectionRef())
+      ProtoSect = getSection("__OBJC2", "__protocol_list");
+    // Return empty if the section doesn't exists.
+    if (ProtoSect == SectionRef())
+      return ProtocolList;
+    if (ProtoSect.getSize() % OwningBinary->getBytesInAddress() != 0)
+      return make_error<StringError>(
+          "objc protocol section size is not a multiple of pointer size",
+          object_error::parse_failed);
+
+    for (unsigned i = 0; i < ProtoSect.getSize();
+         i += OwningBinary->getBytesInAddress())
+      ProtocolList.push_back(ObjCProtocolRef(this, ProtoSect.getAddress() + i));
+  }
+  // TODO: Add support for ObjC1, return empty list for now.
+  return ProtocolList;
+}
+
+Expected<ObjCProtocol>
+MachOMetadata::getObjCProtocolFromRef(ObjCProtocolRef Ref) const {
+  if (OwningBinary->is64Bit()) {
+    if (auto proto_ptr =
+            getResolvedValueFromAddress64(Ref.getRawContent().getValue()))
+      return ObjCProtocol(this, *proto_ptr);
+    else
+      return proto_ptr.takeError();
+  } else {
+    if (auto proto_ptr =
+            getResolvedValueFromAddress32(Ref.getRawContent().getValue()))
+      return ObjCProtocol(this, *proto_ptr);
+    else
+      return proto_ptr.takeError();
+  }
+}
+
+Expected<StringRef> MachOMetadata::getObjCClassName(ObjCClass ClassRef) const {
+  if (isObjC2()) {
+    if (OwningBinary->is64Bit()) {
+      if (auto ro = getObjC2ClassRO64(ClassRef)) {
+        if (auto name = getResolvedValueFromAddress64(
+                ro->getValue() + offsetof(class_ro64_t, name)))
+          return getStringFromAddress(*name);
+        else
+          return name.takeError();
+      } else
+        return ro.takeError();
+    } else {
+      if (auto ro = getObjC2ClassRO32(ClassRef)) {
+        if (auto name = getResolvedValueFromAddress32(
+                ro->getValue() + offsetof(class_ro32_t, name)))
+          return getStringFromAddress(*name);
+        else
+          return name.takeError();
+      } else
+        return ro.takeError();
+    }
+  } else if (isObjC1()) {
+    if (auto name = getResolvedValueFromAddress32(
+            ClassRef.getRawContent().getValue() + offsetof(objc_class_t, name)))
+      return getStringFromAddress(*name);
+    else
+      return name.takeError();
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<StringRef> MachOMetadata::getObjCSuperClassName(ObjCClass Data) const {
+  if (isObjC2()) {
+    if (OwningBinary->is64Bit()) {
+      uint64_t superAddr =
+          Data.getRawContent().getValue() + offsetof(class64_t, superclass);
+      ObjCClassRef super(this, superAddr);
+      return super.getClassName();
+    } else {
+      uint64_t superAddr =
+          Data.getRawContent().getValue() + offsetof(class32_t, superclass);
+      ObjCClassRef super(this, superAddr);
+      return super.getClassName();
+    }
+  } else if (isObjC1()) {
+    if (auto super = getResolvedValueFromAddress32(
+            Data.getRawContent().getValue() +
+            offsetof(objc_class_t, super_class))) {
+      if (*super)
+        return getStringFromAddress(*super);
+      else
+        return StringRef();
+    } else
+      return super.takeError();
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<bool> MachOMetadata::isObjCClassSwift(ObjCClass Data) const {
+  if (isObjC1())
+    return false;
+  if (OwningBinary->is64Bit()) {
+    if (auto class_ro = getResolvedValueFromAddress64(
+            Data.getRawContent().getValue() + offsetof(class64_t, data))) {
+      return ((*class_ro & ~0x7) != 0);
+    } else
+      return class_ro.takeError();
+  } else {
+    if (auto class_ro = getResolvedValueFromAddress32(
+            Data.getRawContent().getValue() + offsetof(class32_t, data))) {
+      return ((*class_ro & ~0x3) != 0);
+    } else
+      return class_ro.takeError();
+  }
+}
+
+Expected<bool> MachOMetadata::isObjCClassMetaClass(ObjCClass Data) const {
+  if (isObjC2()) {
+    if (OwningBinary->is64Bit()) {
+      if (auto class_ro = getObjC2ClassRO64(Data)) {
+        uint32_t f;
+        if (auto flags = getValueFromAddress(class_ro->getValue() +
+                                                 offsetof(class_ro64_t, flags),
+                                             sizeof(f))) {
+          memcpy(&f, flags->data(), sizeof(f));
+          if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+            sys::swapByteOrder(f);
+          return ((f & RO_META) != 0);
+        } else
+          return flags.takeError();
+      } else
+        return class_ro.takeError();
+    } else {
+      if (auto class_ro = getObjC2ClassRO32(Data)) {
+        uint32_t f;
+        if (auto flags = getValueFromAddress(class_ro->getValue() +
+                                                 offsetof(class_ro32_t, flags),
+                                             sizeof(f))) {
+          memcpy(&f, flags->data(), sizeof(f));
+          if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+            sys::swapByteOrder(f);
+          return ((f & RO_META) != 0);
+        } else
+          return flags.takeError();
+      } else
+        return class_ro.takeError();
+    }
+  } else if (isObjC1()) {
+    int32_t clsInfo;
+    if (auto ClassInfo = getValueFromAddress(Data.getRawContent().getValue() +
+                                                 offsetof(objc_class_t, info),
+                                             sizeof(clsInfo))) {
+      memcpy(&clsInfo, ClassInfo->data(), sizeof(clsInfo));
+      if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+        sys::swapByteOrder(clsInfo);
+      return (clsInfo & CLS_META);
+    } else
+      return ClassInfo.takeError();
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<ObjCPropertyList>
+MachOMetadata::materializePropertyList(ObjCClass ClassRef) const {
+  ObjCPropertyList PropertyList;
+  if (isObjC2()) {
+    if (OwningBinary->is64Bit()) {
+      if (auto ro = getObjC2ClassRO64(ClassRef)) {
+        if (auto baseProperties = getResolvedValueFromAddress64(
+                ro->getValue() + offsetof(class_ro64_t, baseProperties))) {
+          if (!*baseProperties)
+            return PropertyList;
+          objc_property_list64 propList;
+          if (auto pList =
+                  getValueFromAddress(*baseProperties, sizeof(propList)))
+            memcpy(&propList, pList->data(), sizeof(propList));
+          else
+            return pList.takeError();
+          if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+            swapStruct(propList);
+          for (unsigned i = 0; i < propList.count; ++i)
+            PropertyList.push_back(ObjCProperty(
+                this, *baseProperties + sizeof(objc_property_list64) +
+                          i * sizeof(objc_property64)));
+          return PropertyList;
+        } else
+          return baseProperties.takeError();
+      } else
+        return ro.takeError();
+    } else {
+      if (auto ro = getObjC2ClassRO32(ClassRef)) {
+        if (auto baseProperties = getResolvedValueFromAddress32(
+                ro->getValue() + offsetof(class_ro32_t, baseProperties))) {
+          if (!*baseProperties)
+            return PropertyList;
+          objc_property_list32 propList;
+          if (auto pList =
+                  getValueFromAddress(*baseProperties, sizeof(propList)))
+            memcpy(&propList, pList->data(), sizeof(propList));
+          else
+            return pList.takeError();
+          if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+            swapStruct(propList);
+          for (unsigned i = 0; i < propList.count; ++i)
+            PropertyList.push_back(ObjCProperty(
+                this, *baseProperties + sizeof(objc_property_list32) +
+                          i * sizeof(objc_property32)));
+          return PropertyList;
+        } else
+          return baseProperties.takeError();
+      } else
+        return ro.takeError();
+    }
+  } else if (isObjC1()) {
+    // Just return empty list.
+    return PropertyList;
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<ObjCPropertyList>
+MachOMetadata::materializeClassPropertyList(ObjCClass ClassRef) const {
+  if (isObjC2()) {
+    if (OwningBinary->is64Bit()) {
+      if (auto meta = getObjC2MetaClass64(ClassRef)) {
+        if (meta->getRawContent().getValue() == 0)
+          return ObjCPropertyList();
+        else
+          return materializePropertyList(*meta);
+      } else
+        return meta.takeError();
+    } else {
+      if (auto meta = getObjC2MetaClass32(ClassRef)) {
+        if (meta->getRawContent().getValue() == 0)
+          return ObjCPropertyList();
+        else
+          return materializePropertyList(*meta);
+      } else
+        return meta.takeError();
+    }
+  } else if (isObjC1())
+    return ObjCPropertyList();
+
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<StringRef> MachOMetadata::getPropertyName(ObjCProperty Data) const {
+  if (!isObjC2())
+    return unsupportedObjCRuntimeError();
+  if (OwningBinary->is64Bit()) {
+    if (auto propName = getResolvedValueFromAddress64(
+            Data.getRawContent().getValue() + offsetof(objc_property64, name)))
+      return getStringFromAddress(*propName);
+    else
+      return propName.takeError();
+  } else {
+    if (auto propName = getResolvedValueFromAddress32(
+            Data.getRawContent().getValue() + offsetof(objc_property32, name)))
+      return getStringFromAddress(*propName);
+    else
+      return propName.takeError();
+  }
+}
+
+Expected<StringRef>
+MachOMetadata::getPropertyAttribute(ObjCProperty Data) const {
+  if (!isObjC2())
+    return unsupportedObjCRuntimeError();
+  if (OwningBinary->is64Bit()) {
+    if (auto propAttr = getResolvedValueFromAddress64(
+            Data.getRawContent().getValue() +
+            offsetof(objc_property64, attributes)))
+      return getStringFromAddress(*propAttr);
+    else
+      return propAttr.takeError();
+  } else {
+    if (auto propAttr = getResolvedValueFromAddress32(
+            Data.getRawContent().getValue() +
+            offsetof(objc_property32, attributes)))
+      return getStringFromAddress(*propAttr);
+    else
+      return propAttr.takeError();
+  }
+}
+
+Expected<ObjCMethodList>
+MachOMetadata::materializeInstanceMethodList(ObjCClass ClassRef) const {
+  if (isObjC2()) {
+    ObjCMethodList MethodList;
+    if (OwningBinary->is64Bit()) {
+      if (auto ro = getObjC2ClassRO64(ClassRef)) {
+        if (auto baseMethods = getResolvedValueFromAddress64(
+                ro->getValue() + offsetof(class_ro64_t, baseMethods))) {
+          if (!*baseMethods)
+            return MethodList;
+          method_list64_t methodList;
+          if (auto mList =
+                  getValueFromAddress(*baseMethods, sizeof(methodList)))
+            memcpy(&methodList, mList->data(), sizeof(methodList));
+          else
+            return mList.takeError();
+          if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+            swapStruct(methodList);
+          for (unsigned i = 0; i < methodList.count; ++i)
+            MethodList.push_back(ObjCMethod(this, *baseMethods +
+                                                      sizeof(method_list64_t) +
+                                                      i * sizeof(method64_t)));
+          return MethodList;
+        } else
+          return baseMethods.takeError();
+      } else
+        return ro.takeError();
+    } else {
+      if (auto ro = getObjC2ClassRO32(ClassRef)) {
+        if (auto baseMethods = getResolvedValueFromAddress32(
+                ro->getValue() + offsetof(class_ro32_t, baseMethods))) {
+          if (!*baseMethods)
+            return MethodList;
+          method_list32_t methodList;
+          if (auto mList =
+                  getValueFromAddress(*baseMethods, sizeof(methodList)))
+            memcpy(&methodList, mList->data(), sizeof(methodList));
+          else
+            return mList.takeError();
+          if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+            swapStruct(methodList);
+          for (unsigned i = 0; i < methodList.count; ++i)
+            MethodList.push_back(ObjCMethod(this, *baseMethods +
+                                                      sizeof(method_list32_t) +
+                                                      i * sizeof(method32_t)));
+          return MethodList;
+        } else
+          return baseMethods.takeError();
+      } else
+        return ro.takeError();
+    }
+  } else if (isObjC1()) {
+    uint64_t methods = ClassRef.getRawContent().getValue() +
+                       offsetof(objc_class_t, methodLists);
+    return getObjC1MethodList(ObjCRef(methods));
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<ObjCMethodList>
+MachOMetadata::materializeClassMethodList(ObjCClass ClassRef) const {
+  if (isObjC2()) {
+    if (OwningBinary->is64Bit()) {
+      if (auto meta = getObjC2MetaClass64(ClassRef)) {
+        if (meta->getRawContent().getValue() == 0)
+          return ObjCMethodList();
+        else
+          return materializeInstanceMethodList(*meta);
+      } else
+        return meta.takeError();
+    } else {
+      if (auto meta = getObjC2MetaClass32(ClassRef)) {
+        if (meta->getRawContent().getValue() == 0)
+          return ObjCMethodList();
+        else
+          return materializeInstanceMethodList(*meta);
+      } else
+        return meta.takeError();
+    }
+  } else if (isObjC1()) {
+    ObjCClassRef isa(this, ClassRef.getRawContent().getValue() +
+                               offsetof(objc_class_t, isa));
+    auto C = getObjCClassFromRef(isa);
+    if (!C)
+      return C.takeError();
+    return materializeInstanceMethodList(*C);
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<StringRef> MachOMetadata::getObjCCategoryName(ObjCCategory Cat) const {
+  if (isObjC2()) {
+    if (OwningBinary->is64Bit()) {
+      if (auto name = getResolvedValueFromAddress64(
+              Cat.getRawContent().getValue() + offsetof(category64_t, name)))
+        return getStringFromAddress(*name);
+      else
+        return name.takeError();
+    } else {
+      if (auto name = getResolvedValueFromAddress32(
+              Cat.getRawContent().getValue() + offsetof(category32_t, name)))
+        return getStringFromAddress(*name);
+      else
+        return name.takeError();
+    }
+  } else if (isObjC1()) {
+    if (auto name = getResolvedValueFromAddress32(
+            Cat.getRawContent().getValue() +
+            offsetof(objc_category_t, category_name)))
+      return getStringFromAddress(*name);
+    else
+      return name.takeError();
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<StringRef>
+MachOMetadata::getObjCCategoryBaseClassName(ObjCCategory Cat) const {
+  if (isObjC2()) {
+    if (OwningBinary->is64Bit()) {
+      uint64_t baseClassAddr =
+          Cat.getRawContent().getValue() + offsetof(category64_t, cls);
+      ObjCClassRef cls(this, baseClassAddr);
+      if (auto clsName = cls.getClassName())
+        return *clsName;
+      else
+        return clsName.takeError();
+    } else {
+      uint64_t baseClassAddr =
+          Cat.getRawContent().getValue() + offsetof(category32_t, cls);
+      ObjCClassRef cls(this, baseClassAddr);
+      if (auto clsName = cls.getClassName())
+        return *clsName;
+      else
+        return clsName.takeError();
+    }
+  } else if (isObjC1()) {
+    if (auto name = getResolvedValueFromAddress32(
+            Cat.getRawContent().getValue() +
+            offsetof(objc_category_t, class_name)))
+      return getStringFromAddress(*name);
+    else
+      return name.takeError();
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<ObjCPropertyList>
+MachOMetadata::materializePropertyList(ObjCCategory Data) const {
+  if (isObjC2()) {
+    ObjCPropertyList PropertyList;
+    if (OwningBinary->is64Bit()) {
+      if (auto iprop = getResolvedValueFromAddress64(
+              Data.getRawContent().getValue() +
+              offsetof(category64_t, instanceProperties))) {
+        if (*iprop == 0)
+          return PropertyList;
+
+        objc_property_list64 propList;
+        if (auto pList = getValueFromAddress(*iprop, sizeof(propList)))
+          memcpy(&propList, pList->data(), sizeof(propList));
+        else
+          return pList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(propList);
+        for (unsigned i = 0; i < propList.count; ++i)
+          PropertyList.push_back(
+              ObjCProperty(this, *iprop + sizeof(objc_property_list64) +
+                                     i * sizeof(objc_property64)));
+        return PropertyList;
+      } else
+        return iprop.takeError();
+    } else {
+      if (auto iprop = getResolvedValueFromAddress32(
+              Data.getRawContent().getValue() +
+              offsetof(category32_t, instanceProperties))) {
+        if (*iprop == 0)
+          return PropertyList;
+
+        objc_property_list32 propList;
+        if (auto pList = getValueFromAddress(*iprop, sizeof(propList)))
+          memcpy(&propList, pList->data(), sizeof(propList));
+        else
+          return pList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(propList);
+        for (unsigned i = 0; i < propList.count; ++i)
+          PropertyList.push_back(
+              ObjCProperty(this, *iprop + sizeof(objc_property_list32) +
+                                     i * sizeof(objc_property32)));
+        return PropertyList;
+      } else
+        return iprop.takeError();
+    }
+  } else if (isObjC1())
+    return ObjCPropertyList();
+
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<ObjCMethodList>
+MachOMetadata::materializeInstanceMethodList(ObjCCategory Data) const {
+  if (isObjC2()) {
+    ObjCMethodList MethodList;
+    if (OwningBinary->is64Bit()) {
+      if (auto iprop = getResolvedValueFromAddress64(
+              Data.getRawContent().getValue() +
+              offsetof(category64_t, instanceMethods))) {
+        if (*iprop == 0)
+          return MethodList;
+
+        method_list64_t methodList;
+        if (auto mList = getValueFromAddress(*iprop, sizeof(methodList)))
+          memcpy(&methodList, mList->data(), sizeof(methodList));
+        else
+          return mList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(methodList);
+        for (unsigned i = 0; i < methodList.count; ++i)
+          MethodList.push_back(ObjCMethod(
+              this, *iprop + sizeof(method_list64_t) + i * sizeof(method64_t)));
+        return MethodList;
+      } else
+        return iprop.takeError();
+    } else {
+      if (auto iprop = getResolvedValueFromAddress32(
+              Data.getRawContent().getValue() +
+              offsetof(category32_t, instanceMethods))) {
+        if (*iprop == 0)
+          return MethodList;
+
+        method_list32_t methodList;
+        if (auto mList = getValueFromAddress(*iprop, sizeof(methodList)))
+          memcpy(&methodList, mList->data(), sizeof(methodList));
+        else
+          return mList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(methodList);
+        for (unsigned i = 0; i < methodList.count; ++i)
+          MethodList.push_back(ObjCMethod(
+              this, *iprop + sizeof(method_list32_t) + i * sizeof(method32_t)));
+        return MethodList;
+      } else
+        return iprop.takeError();
+    }
+  } else if (isObjC1()) {
+    uint64_t methods = Data.getRawContent().getValue() +
+                       offsetof(objc_category_t, instance_methods);
+    return getObjC1MethodList(ObjCRef(methods));
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<ObjCMethodList>
+MachOMetadata::materializeClassMethodList(ObjCCategory Data) const {
+  if (isObjC2()) {
+    ObjCMethodList MethodList;
+    if (OwningBinary->is64Bit()) {
+      if (auto iprop = getResolvedValueFromAddress64(
+              Data.getRawContent().getValue() +
+              offsetof(category64_t, classMethods))) {
+        if (*iprop == 0)
+          return MethodList;
+
+        method_list64_t methodList;
+        if (auto mList = getValueFromAddress(*iprop, sizeof(methodList)))
+          memcpy(&methodList, mList->data(), sizeof(methodList));
+        else
+          return mList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(methodList);
+        for (unsigned i = 0; i < methodList.count; ++i)
+          MethodList.push_back(ObjCMethod(
+              this, *iprop + sizeof(method_list64_t) + i * sizeof(method64_t)));
+        return MethodList;
+      } else
+        return iprop.takeError();
+    } else {
+      if (auto iprop = getResolvedValueFromAddress32(
+              Data.getRawContent().getValue() +
+              offsetof(category32_t, classMethods))) {
+        if (*iprop == 0)
+          return MethodList;
+
+        method_list32_t methodList;
+        if (auto mList = getValueFromAddress(*iprop, sizeof(methodList)))
+          memcpy(&methodList, mList->data(), sizeof(methodList));
+        else
+          return mList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(methodList);
+        for (unsigned i = 0; i < methodList.count; ++i)
+          MethodList.push_back(ObjCMethod(
+              this, *iprop + sizeof(method_list32_t) + i * sizeof(method32_t)));
+        return MethodList;
+      } else
+        return iprop.takeError();
+    }
+  } else if (isObjC1()) {
+    uint64_t methods = Data.getRawContent().getValue() +
+                       offsetof(objc_category_t, class_methods);
+    return getObjC1MethodList(ObjCRef(methods));
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<StringRef>
+MachOMetadata::getObjCProtocolName(ObjCProtocol Data) const {
+  if (isObjC2()) {
+    if (OwningBinary->is64Bit()) {
+      if (auto name = getResolvedValueFromAddress64(
+              Data.getRawContent().getValue() + offsetof(protocol64_t, name)))
+        return getStringFromAddress(*name);
+      else
+        return name.takeError();
+    } else {
+      if (auto name = getResolvedValueFromAddress32(
+              Data.getRawContent().getValue() + offsetof(protocol32_t, name)))
+        return getStringFromAddress(*name);
+      else
+        return name.takeError();
+    }
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<ObjCPropertyList>
+MachOMetadata::materializePropertyList(ObjCProtocol Data) const {
+  if (isObjC2()) {
+    ObjCPropertyList PropertyList;
+    if (OwningBinary->is64Bit()) {
+      if (auto iprop = getResolvedValueFromAddress64(
+              Data.getRawContent().getValue() +
+              offsetof(protocol64_t, instanceProperties))) {
+        if (*iprop == 0)
+          return PropertyList;
+
+        objc_property_list64 propList;
+        if (auto pList = getValueFromAddress(*iprop, sizeof(propList)))
+          memcpy(&propList, pList->data(), sizeof(propList));
+        else
+          return pList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(propList);
+        for (unsigned i = 0; i < propList.count; ++i)
+          PropertyList.push_back(
+              ObjCProperty(this, *iprop + sizeof(objc_property_list64) +
+                                     i * sizeof(objc_property64)));
+        return PropertyList;
+      } else
+        return iprop.takeError();
+    } else {
+      if (auto iprop = getResolvedValueFromAddress32(
+              Data.getRawContent().getValue() +
+              offsetof(protocol32_t, instanceProperties))) {
+        if (*iprop == 0)
+          return PropertyList;
+
+        objc_property_list32 propList;
+        if (auto pList = getValueFromAddress(*iprop, sizeof(propList)))
+          memcpy(&propList, pList->data(), sizeof(propList));
+        else
+          return pList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(propList);
+        for (unsigned i = 0; i < propList.count; ++i)
+          PropertyList.push_back(
+              ObjCProperty(this, *iprop + sizeof(objc_property_list32) +
+                                     i * sizeof(objc_property32)));
+        return PropertyList;
+      } else
+        return iprop.takeError();
+    }
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<ObjCMethodList>
+MachOMetadata::materializeInstanceMethodList(ObjCProtocol Data) const {
+  if (isObjC2()) {
+    ObjCMethodList MethodList;
+    if (OwningBinary->is64Bit()) {
+      if (auto iprop = getResolvedValueFromAddress64(
+              Data.getRawContent().getValue() +
+              offsetof(protocol64_t, instanceMethods))) {
+        if (*iprop == 0)
+          return MethodList;
+
+        method_list64_t methodList;
+        if (auto mList = getValueFromAddress(*iprop, sizeof(methodList)))
+          memcpy(&methodList, mList->data(), sizeof(methodList));
+        else
+          return mList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(methodList);
+        for (unsigned i = 0; i < methodList.count; ++i)
+          MethodList.push_back(ObjCMethod(
+              this, *iprop + sizeof(method_list64_t) + i * sizeof(method64_t)));
+        return MethodList;
+      } else
+        return iprop.takeError();
+    } else {
+      if (auto iprop = getResolvedValueFromAddress32(
+              Data.getRawContent().getValue() +
+              offsetof(protocol32_t, instanceMethods))) {
+        if (*iprop == 0)
+          return MethodList;
+
+        method_list32_t methodList;
+        if (auto mList = getValueFromAddress(*iprop, sizeof(methodList)))
+          memcpy(&methodList, mList->data(), sizeof(methodList));
+        else
+          return mList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(methodList);
+        for (unsigned i = 0; i < methodList.count; ++i)
+          MethodList.push_back(ObjCMethod(
+              this, *iprop + sizeof(method_list32_t) + i * sizeof(method32_t)));
+        return MethodList;
+      } else
+        return iprop.takeError();
+    }
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<ObjCMethodList>
+MachOMetadata::materializeClassMethodList(ObjCProtocol Data) const {
+  if (isObjC2()) {
+    ObjCMethodList MethodList;
+    if (OwningBinary->is64Bit()) {
+      if (auto iprop = getResolvedValueFromAddress64(
+              Data.getRawContent().getValue() +
+              offsetof(protocol64_t, classMethods))) {
+        if (*iprop == 0)
+          return MethodList;
+
+        method_list64_t methodList;
+        if (auto mList = getValueFromAddress(*iprop, sizeof(methodList)))
+          memcpy(&methodList, mList->data(), sizeof(methodList));
+        else
+          return mList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(methodList);
+        for (unsigned i = 0; i < methodList.count; ++i)
+          MethodList.push_back(ObjCMethod(
+              this, *iprop + sizeof(method_list64_t) + i * sizeof(method64_t)));
+        return MethodList;
+      } else
+        return iprop.takeError();
+    } else {
+      if (auto iprop = getResolvedValueFromAddress32(
+              Data.getRawContent().getValue() +
+              offsetof(protocol32_t, classMethods))) {
+        if (*iprop == 0)
+          return MethodList;
+
+        method_list32_t methodList;
+        if (auto mList = getValueFromAddress(*iprop, sizeof(methodList)))
+          memcpy(&methodList, mList->data(), sizeof(methodList));
+        else
+          return mList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(methodList);
+        for (unsigned i = 0; i < methodList.count; ++i)
+          MethodList.push_back(ObjCMethod(
+              this, *iprop + sizeof(method_list32_t) + i * sizeof(method32_t)));
+        return MethodList;
+      } else
+        return iprop.takeError();
+    }
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<ObjCMethodList>
+MachOMetadata::materializeOptionalInstanceMethodList(ObjCProtocol Data) const {
+  if (isObjC2()) {
+    ObjCMethodList MethodList;
+    if (OwningBinary->is64Bit()) {
+      if (auto iprop = getResolvedValueFromAddress64(
+              Data.getRawContent().getValue() +
+              offsetof(protocol64_t, optionalInstanceMethods))) {
+        if (*iprop == 0)
+          return MethodList;
+
+        method_list64_t methodList;
+        if (auto mList = getValueFromAddress(*iprop, sizeof(methodList)))
+          memcpy(&methodList, mList->data(), sizeof(methodList));
+        else
+          return mList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(methodList);
+        for (unsigned i = 0; i < methodList.count; ++i)
+          MethodList.push_back(ObjCMethod(
+              this, *iprop + sizeof(method_list64_t) + i * sizeof(method64_t)));
+        return MethodList;
+      } else
+        return iprop.takeError();
+    } else {
+      if (auto iprop = getResolvedValueFromAddress32(
+              Data.getRawContent().getValue() +
+              offsetof(protocol32_t, optionalInstanceMethods))) {
+        if (*iprop == 0)
+          return MethodList;
+
+        method_list32_t methodList;
+        if (auto mList = getValueFromAddress(*iprop, sizeof(methodList)))
+          memcpy(&methodList, mList->data(), sizeof(methodList));
+        else
+          return mList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(methodList);
+        for (unsigned i = 0; i < methodList.count; ++i)
+          MethodList.push_back(ObjCMethod(
+              this, *iprop + sizeof(method_list32_t) + i * sizeof(method32_t)));
+        return MethodList;
+      } else
+        return iprop.takeError();
+    }
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<ObjCMethodList>
+MachOMetadata::materializeOptionalClassMethodList(ObjCProtocol Data) const {
+  if (isObjC2()) {
+    ObjCMethodList MethodList;
+    if (OwningBinary->is64Bit()) {
+      if (auto iprop = getResolvedValueFromAddress64(
+              Data.getRawContent().getValue() +
+              offsetof(protocol64_t, optionalClassMethods))) {
+        if (*iprop == 0)
+          return MethodList;
+
+        method_list64_t methodList;
+        if (auto mList = getValueFromAddress(*iprop, sizeof(methodList)))
+          memcpy(&methodList, mList->data(), sizeof(methodList));
+        else
+          return mList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(methodList);
+        for (unsigned i = 0; i < methodList.count; ++i)
+          MethodList.push_back(ObjCMethod(
+              this, *iprop + sizeof(method_list64_t) + i * sizeof(method64_t)));
+        return MethodList;
+      } else
+        return iprop.takeError();
+    } else {
+      if (auto iprop = getResolvedValueFromAddress32(
+              Data.getRawContent().getValue() +
+              offsetof(protocol32_t, optionalClassMethods))) {
+        if (*iprop == 0)
+          return MethodList;
+
+        method_list32_t methodList;
+        if (auto mList = getValueFromAddress(*iprop, sizeof(methodList)))
+          memcpy(&methodList, mList->data(), sizeof(methodList));
+        else
+          return mList.takeError();
+        if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+          swapStruct(methodList);
+        for (unsigned i = 0; i < methodList.count; ++i)
+          MethodList.push_back(ObjCMethod(
+              this, *iprop + sizeof(method_list32_t) + i * sizeof(method32_t)));
+        return MethodList;
+      } else
+        return iprop.takeError();
+    }
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<StringRef> MachOMetadata::getMethodName(ObjCMethod Data) const {
+  if (isObjC1() || isObjC2()) {
+    if (OwningBinary->is64Bit()) {
+      if (auto methodName = getResolvedValueFromAddress64(
+              Data.getRawContent().getValue() + offsetof(method64_t, name)))
+        return getStringFromAddress(*methodName);
+      else
+        return methodName.takeError();
+    } else {
+      if (auto methodName = getResolvedValueFromAddress32(
+              Data.getRawContent().getValue() + offsetof(method32_t, name)))
+        return getStringFromAddress(*methodName);
+      else
+        return methodName.takeError();
+    }
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<StringRef> MachOMetadata::getMethodType(ObjCMethod Data) const {
+  if (isObjC1() || isObjC2()) {
+    if (OwningBinary->is64Bit()) {
+      if (auto methodTypes = getResolvedValueFromAddress64(
+              Data.getRawContent().getValue() + offsetof(method64_t, types)))
+        return getStringFromAddress(*methodTypes);
+      else
+        return methodTypes.takeError();
+    } else {
+      if (auto methodTypes = getResolvedValueFromAddress32(
+              Data.getRawContent().getValue() + offsetof(method32_t, types)))
+        return getStringFromAddress(*methodTypes);
+      else
+        return methodTypes.takeError();
+    }
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+Expected<ObjCSelectorList> MachOMetadata::referencedSelectors() const {
+  ObjCSelectorList SelectorList;
+  SectionRef SelSect = getSection("__DATA", "__objc_selrefs");
+  // Return empty if the section doesn't exists.
+  if (SelSect == SectionRef())
+    return SelectorList;
+
+  if (SelSect.getSize() % OwningBinary->getBytesInAddress() != 0)
+    return make_error<StringError>(
+        "objc class section size is not a multiple of pointer size",
+        object_error::parse_failed);
+
+  for (unsigned i = 0; i < SelSect.getSize();
+       i += OwningBinary->getBytesInAddress())
+    SelectorList.push_back(ObjCSelectorRef(this, SelSect.getAddress() + i));
+
+  return SelectorList;
+}
+
+Expected<StringRef>
+MachOMetadata::getObjCSelectorName(ObjCSelectorRef Ref) const {
+  if (isObjC2()) {
+    if (OwningBinary->is64Bit()) {
+      if (auto sel =
+              getResolvedValueFromAddress64(Ref.getRawContent().getValue()))
+        return getStringFromAddress(*sel);
+      else
+        return sel.takeError();
+    } else {
+      if (auto sel =
+              getResolvedValueFromAddress32(Ref.getRawContent().getValue()))
+        return getStringFromAddress(*sel);
+      else
+        return sel.takeError();
+    }
+  }
+  return unsupportedObjCRuntimeError();
+}
+
+void MachOMetadata::getAllPotentiallyDefinedSelectors(StringSet<> &Set) const {
+  // Clear the set.
+  Set.clear();
+  SectionRef ObjCConstSect = getSection("__DATA_CONST", "__objc_const");
+  if (ObjCConstSect == SectionRef())
+    ObjCConstSect = getSection("__DATA", "__objc_const");
+  SectionRef MethodNameSect = getSection("__TEXT", "__objc_methname");
+  if (ObjCConstSect == SectionRef() || MethodNameSect == SectionRef())
+    return;
+
+  auto ignoreError = [](Error &&E) {
+    handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
+      return; // ignore.
+    });
+  };
+
+  if (auto sels = referencedSelectors()) {
+    StringSet<> refSels;
+    for (auto sel : *sels) {
+      if (auto selName = sel.getSelector())
+        refSels.insert(*selName);
+      else
+        ignoreError(selName.takeError());
+    }
+    if (OwningBinary->is64Bit()) {
+      for (uint64_t A = ObjCConstSect.getAddress(),
+                    E = ObjCConstSect.getAddress() + ObjCConstSect.getSize();
+           A < E; A += OwningBinary->getBytesInAddress()) {
+        auto methodName = getResolvedValueFromAddress64(A);
+        if (!methodName) {
+          ignoreError(methodName.takeError());
+          continue;
+        }
+        if (*methodName >= MethodNameSect.getAddress() &&
+            *methodName <
+                MethodNameSect.getAddress() + MethodNameSect.getSize()) {
+          if (auto name = getStringFromAddress(*methodName)) {
+            if (refSels.find(*name) != refSels.end())
+              Set.insert(*name);
+          } else
+            ignoreError(name.takeError());
+        }
+      }
+    } else {
+      for (uint64_t A = ObjCConstSect.getAddress(),
+                    E = ObjCConstSect.getAddress() + ObjCConstSect.getSize();
+           A < E; A += OwningBinary->getBytesInAddress()) {
+        auto methodName = getResolvedValueFromAddress32(A);
+        if (!methodName) {
+          ignoreError(methodName.takeError());
+          continue;
+        }
+        if (*methodName >= MethodNameSect.getAddress() &&
+            *methodName <
+                MethodNameSect.getAddress() + MethodNameSect.getSize()) {
+          if (auto name = getStringFromAddress(*methodName)) {
+            if (refSels.find(*name) != refSels.end())
+              Set.insert(*name);
+          } else
+            ignoreError(name.takeError());
+        }
+      }
+    }
+  } else
+    ignoreError(sels.takeError());
+}
+
+Expected<StringRef> MachOMetadata::getSwiftVersion() const {
+  SectionRef Sect = getSection("__OBJC2", "__module_info");
+  if (Sect == SectionRef())
+    Sect = getSection("__DATA_CONST", "__objc_imageinfo");
+  if (Sect == SectionRef())
+    Sect = getSection("__DATA", "__objc_imageinfo");
+  if (Sect == SectionRef())
+    return "";
+  auto SectContents = Sect.getContents();
+  if (!SectContents)
+    return SectContents.takeError();
+  imageInfo_t info;
+  if (SectContents->size() < sizeof(info))
+    return make_error<StringError>("ObjC Image Info section is too small",
+                                   object_error::parse_failed);
+  memcpy(&info, SectContents->data(), sizeof(info));
+  if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+    swapStruct(info);
+
+  return convertSwiftVersion((info.flags >> 8) & 0xff);
+}
+
+const SectionRef MachOMetadata::getSection(const char *segname,
+                                           const char *sectname) const {
+  for (const SectionRef &Section : OwningBinary->sections()) {
+    StringRef SectName;
+    Section.getName(SectName);
+    DataRefImpl Ref = Section.getRawDataRefImpl();
+    StringRef SegName = OwningBinary->getSectionFinalSegmentName(Ref);
+    if (SegName == segname && SectName == sectname)
+      return Section;
+  }
+  return SectionRef();
+}
+
+Expected<object::SectionRef>
+MachOMetadata::getSectionFromAddress(uint64_t Address) const {
+  for (const SectionRef &Section : OwningBinary->sections()) {
+    uint64_t SectAddress = Section.getAddress();
+    uint64_t SectSize = Section.getSize();
+    if (SectSize == 0)
+      continue;
+    if (Address >= SectAddress && Address < SectAddress + SectSize)
+      return Section;
+  }
+  return make_error<StringError>("requested address not in section",
+                                 object_error::parse_failed);
+}
+
+Expected<StringRef> MachOMetadata::getValueFromAddress(uint64_t Address,
+                                                       uint64_t size,
+                                                       bool objc_only) const {
+  if (isAddressEncrypted(Address))
+    return make_error<StringError>("Value at the address is encrypted",
+                                   object_error::parse_failed);
+
+  for (const SectionRef &Section : OwningBinary->sections()) {
+    uint64_t SectAddress = Section.getAddress();
+    uint64_t SectSize = Section.getSize();
+    if (SectSize == 0)
+      continue;
+    if (objc_only) {
+      StringRef SectName;
+      Section.getName(SectName);
+      DataRefImpl Ref = Section.getRawDataRefImpl();
+      StringRef SegName = OwningBinary->getSectionFinalSegmentName(Ref);
+      if (SegName != "__OBJC" && SectName != "__cstring")
+        continue;
+    }
+    if (Address >= SectAddress && Address < SectAddress + SectSize) {
+      uint64_t offset = Address - SectAddress;
+      auto SectContents = Section.getContents();
+      if (!SectContents)
+        return SectContents.takeError();
+      // size == 0 implies the length of the string.
+      StringRef Target = (size == 0)
+                             ? StringRef(SectContents->data() + offset)
+                             : StringRef(SectContents->data() + offset, size);
+      if (Target.size() + offset > SectSize)
+        return make_error<StringError>(
+            "Data extends pass the end of the section",
+            object_error::parse_failed);
+      return Target;
+    }
+  }
+  return make_error<StringError>("requested address out of bound",
+                                 object_error::parse_failed);
+}
+
+bool MachOMetadata::isAddressEncrypted(uint64_t Address) const {
+  // Find encrypted range.
+  if (OwningBinary->is64Bit()) {
+    uint64_t fileOffset = 0;
+    for (const auto &LC : OwningBinary->load_commands()) {
+      if (LC.C.cmd == MachO::LC_SEGMENT_64) {
+        MachO::segment_command_64 cmd =
+            OwningBinary->getSegment64LoadCommand(LC);
+        if (Address > cmd.vmaddr && Address < cmd.vmaddr + cmd.vmsize)
+          fileOffset = Address - cmd.vmaddr + cmd.fileoff;
+      }
+    }
+    for (const auto &LC : OwningBinary->load_commands()) {
+      if (LC.C.cmd == MachO::LC_ENCRYPTION_INFO_64) {
+        MachO::encryption_info_command_64 cmd =
+            OwningBinary->getEncryptionInfoCommand64(LC);
+        if (cmd.cryptid == 0)
+          continue;
+        if (fileOffset > cmd.cryptoff &&
+            fileOffset < cmd.cryptoff + cmd.cryptsize)
+          return true;
+      }
+    }
+  } else {
+    uint64_t fileOffset = 0;
+    for (const auto &LC : OwningBinary->load_commands()) {
+      if (LC.C.cmd == MachO::LC_SEGMENT) {
+        MachO::segment_command cmd = OwningBinary->getSegmentLoadCommand(LC);
+        if (Address > cmd.vmaddr && Address < cmd.vmaddr + cmd.vmsize)
+          fileOffset = Address - cmd.vmaddr + cmd.fileoff;
+      }
+    }
+    for (const auto &LC : OwningBinary->load_commands()) {
+      if (LC.C.cmd == MachO::LC_ENCRYPTION_INFO) {
+        MachO::encryption_info_command cmd =
+            OwningBinary->getEncryptionInfoCommand(LC);
+        if (cmd.cryptid == 0)
+          continue;
+        if (fileOffset > cmd.cryptoff &&
+            fileOffset < cmd.cryptoff + cmd.cryptsize)
+          return true;
+      }
+    }
+  }
+  return false;
+}
+
+Expected<StringRef> MachOMetadata::getStringFromAddress(uint64_t Address,
+                                                        bool allowEmpty) const {
+  if (isAddressEncrypted(Address))
+    return "#EncryptedString#";
+
+  for (const SectionRef &Section : OwningBinary->sections()) {
+    uint64_t SectAddress = Section.getAddress();
+    uint64_t SectSize = Section.getSize();
+    if (SectSize == 0)
+      continue;
+    if (Address >= SectAddress && Address < SectAddress + SectSize) {
+      uint64_t offset = Address - SectAddress;
+      auto SectContents = Section.getContents();
+      if (!SectContents)
+        return SectContents.takeError();
+      StringRef Target = StringRef(SectContents->data() + offset);
+      if (Target.size() + offset >= SectSize)
+        return make_error<StringError>(
+            "Data extends pass the end of the section",
+            object_error::parse_failed);
+      if (Target.empty() && !allowEmpty)
+        return make_error<StringError>(
+            "Expect to read a none zero length string",
+            object_error::parse_failed);
+
+      return Target;
+    }
+  }
+  return make_error<StringError>("string out of bound",
+                                 object_error::parse_failed);
+}
+
+Expected<StringRef>
+MachOMetadata::getSymbolFromAddress(uint64_t Address, uint64_t &n_value,
+                                    uint64_t &addend,
+                                    uint64_t ReferenceValue) const {
+  // initialize value.
+  n_value = 0;
+  addend = ReferenceValue;
+
+  // See if there is an external relocation entry at the sect_offset.
+  // If there is an external relocation entry for a symbol in this section
+  // at this section_offset then use that symbol's value for the n_value
+  // and return its name.
+  auto Reloc = ExternalRelocMap.find(Address);
+  if (Reloc != ExternalRelocMap.end()) {
+    auto Symbol = Reloc->second.getSymbol();
+    n_value = Symbol->getValue();
+    Expected<StringRef> NameOrError = Symbol->getName();
+    if (!NameOrError) {
+      return NameOrError.takeError();
+    }
+    return *NameOrError;
+  }
+  // Check the bind table.
+  auto bindSymbol = AddressToSymbolMap.find(Address);
+  if (bindSymbol != AddressToSymbolMap.end())
+    return bindSymbol->second;
+  return StringRef();
+}
+
+Expected<uint64_t>
+MachOMetadata::getResolvedValueFromAddress64(uint64_t Address) const {
+  uint64_t ptr;
+  if (auto p = getValueFromAddress(Address, sizeof(ptr)))
+    memcpy(&ptr, p->data(), sizeof(ptr));
+  else
+    return p.takeError();
+  if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+    sys::swapByteOrder(ptr);
+  uint64_t offset, addend;
+  if (auto symbol = getSymbolFromAddress(Address, offset, addend, ptr))
+    ptr = offset + addend;
+  else
+    return symbol.takeError();
+  return ptr;
+}
+
+Expected<uint32_t>
+MachOMetadata::getResolvedValueFromAddress32(uint64_t Address) const {
+  uint32_t ptr;
+  if (auto p = getValueFromAddress(Address, sizeof(ptr)))
+    memcpy(&ptr, p->data(), sizeof(ptr));
+  else
+    return p.takeError();
+  if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+    sys::swapByteOrder(ptr);
+  uint64_t offset, addend;
+  if (auto symbol = getSymbolFromAddress(Address, offset, addend))
+    ptr += offset;
+  else
+    return symbol.takeError();
+  return ptr;
+}
+
+Expected<ObjCRef> MachOMetadata::getObjC2ClassRO64(ObjCClass Data) const {
+  assert(isObjC2() && OwningBinary->is64Bit() &&
+         "Only support 64 bit Obj2 runtime");
+  if (auto class_ro = getResolvedValueFromAddress64(
+          Data.getRawContent().getValue() + offsetof(class64_t, data))) {
+    return *class_ro & ~0x7;
+  } else
+    return class_ro.takeError();
+}
+
+Expected<ObjCRef> MachOMetadata::getObjC2ClassRO32(ObjCClass Data) const {
+  assert(isObjC2() && !OwningBinary->is64Bit() &&
+         "Only support 32 bit Obj2 runtime");
+  if (auto class_ro = getResolvedValueFromAddress32(
+          Data.getRawContent().getValue() + offsetof(class32_t, data))) {
+    return *class_ro & ~0x3;
+  } else
+    return class_ro.takeError();
+}
+
+Expected<ObjCClass> MachOMetadata::getObjC2MetaClass64(ObjCClass Data) const {
+  assert(isObjC2() && OwningBinary->is64Bit() &&
+         "Only support 64 bit Obj2 runtime");
+  if (auto isa = getResolvedValueFromAddress64(Data.getRawContent().getValue() +
+                                               offsetof(class64_t, isa))) {
+    if (*isa) {
+      return ObjCClass(this, *isa);
+    } else
+      return ObjCClass(this);
+  } else
+    return isa.takeError();
+}
+
+Expected<ObjCClass> MachOMetadata::getObjC2MetaClass32(ObjCClass Data) const {
+  assert(isObjC2() && !OwningBinary->is64Bit() &&
+         "Only support 32 bit Obj2 runtime");
+  if (auto isa = getResolvedValueFromAddress32(Data.getRawContent().getValue() +
+                                               offsetof(class32_t, isa))) {
+    if (*isa) {
+      return ObjCClass(this, *isa);
+    } else
+      return ObjCClass(this);
+  } else
+    return isa.takeError();
+}
+
+Expected<ObjCRefList> MachOMetadata::getObjC1Modules() const {
+  ObjCRefList Modules;
+  auto ModuleInfo = getSection("__OBJC", "__module_info");
+  if (ModuleInfo == SectionRef())
+    return Modules;
+
+  if (ModuleInfo.getSize() % sizeof(objc_module_t) != 0)
+    return make_error<StringError>(
+        "__module_info is not a multiple of objc_module_t size",
+        object_error::parse_failed);
+
+  for (unsigned i = 0; i < ModuleInfo.getSize(); i += sizeof(objc_module_t))
+    Modules.push_back(ModuleInfo.getAddress() + i);
+
+  return Modules;
+}
+
+Expected<ObjCRef> MachOMetadata::getObjC1Symtab(ObjCRef ObjCModule) const {
+  if (auto sym = getResolvedValueFromAddress32(ObjCModule.getValue() +
+                                               offsetof(objc_module_t, symtab)))
+    return ObjCRef(*sym);
+  else
+    return sym.takeError();
+}
+
+Expected<ObjCClassList>
+MachOMetadata::getObjC1ClassesFromSymtab(ObjCRef Symtab) const {
+  ObjCClassList Classes;
+  auto def_start = Symtab.getValue() + sizeof(objc_symtab_t);
+  auto cls_count = getValueFromAddress(Symtab.getValue() +
+                                           offsetof(objc_symtab_t, cls_def_cnt),
+                                       sizeof(objc_symtab_t::cls_def_cnt));
+  if (!cls_count)
+    return cls_count.takeError();
+
+  uint16_t count;
+  memcpy(&count, cls_count->data(), sizeof(count));
+  if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+    sys::swapByteOrder(count);
+
+  auto section = getSectionFromAddress(def_start);
+  if (section) {
+    if ((def_start + count) > (section->getAddress() + section->getSize()))
+      return make_error<StringError>("Symtab extends out of the range",
+                                     object_error::parse_failed);
+  } else
+    return section.takeError();
+
+  for (unsigned i = 0; i < count; ++i)
+    Classes.push_back(ObjCClassRef(this, def_start + i * sizeof(uint32_t)));
+
+  return Classes;
+}
+
+Expected<ObjCCategoryList>
+MachOMetadata::getObjC1CategoriesFromSymtab(ObjCRef Symtab) const {
+  ObjCCategoryList Categories;
+  auto cls_count = getValueFromAddress(Symtab.getValue() +
+                                           offsetof(objc_symtab_t, cls_def_cnt),
+                                       sizeof(objc_symtab_t::cls_def_cnt));
+  if (!cls_count)
+    return cls_count.takeError();
+
+  uint16_t count;
+  memcpy(&count, cls_count->data(), sizeof(count));
+  if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+    sys::swapByteOrder(count);
+  auto def_start =
+      Symtab.getValue() + sizeof(objc_symtab_t) + count * sizeof(uint32_t);
+
+  auto cat_count = getValueFromAddress(Symtab.getValue() +
+                                           offsetof(objc_symtab_t, cat_def_cnt),
+                                       sizeof(objc_symtab_t::cat_def_cnt));
+  if (!cat_count)
+    return cat_count.takeError();
+
+  memcpy(&count, cat_count->data(), sizeof(count));
+  if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+    sys::swapByteOrder(count);
+
+  auto section = getSectionFromAddress(def_start);
+  if (section) {
+    if ((def_start + count) > (section->getAddress() + section->getSize()))
+      return make_error<StringError>("Symtab extends out of the range",
+                                     object_error::parse_failed);
+  } else
+    return section.takeError();
+
+  for (unsigned i = 0; i < count; ++i)
+    Categories.push_back(
+        ObjCCategoryRef(this, def_start + i * sizeof(uint32_t)));
+
+  return Categories;
+}
+
+Expected<ObjCMethodList>
+MachOMetadata::getObjC1MethodList(ObjCRef Methods) const {
+  auto ML = getResolvedValueFromAddress32(Methods.getValue());
+  if (!ML)
+    return ML.takeError();
+  if (!*ML)
+    return ObjCMethodList();
+  objc_method_list_t list;
+  auto L = getValueFromAddress(*ML, sizeof(list));
+  if (!L)
+    return L.takeError();
+  memcpy(&list, L->data(), sizeof(list));
+  if (OwningBinary->isLittleEndian() != sys::IsLittleEndianHost)
+    swapStruct(list);
+
+  ObjCMethodList MethodList;
+  uint64_t start = *ML + sizeof(objc_method_list_t);
+
+  auto section = getSectionFromAddress(start);
+  if (section) {
+    if ((start + list.method_count) >
+        (section->getAddress() + section->getSize()))
+      return make_error<StringError>("Method list extends out of the range",
+                                     object_error::parse_failed);
+  } else
+    return section.takeError();
+
+  for (int32_t i = 0; i < list.method_count; ++i)
+    MethodList.push_back(ObjCMethod(this, start + i * sizeof(objc_method_t)));
+
+  return MethodList;
+}

llvm/lib/Object/ObjCMetadata/ObjCMetadata.cpp

+//===- ObjCMetadata.cpp - ObjC Metadata Reader ------------------*- C++ -*-===//
+//
+// 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 file defines the classes needed to parse ObjCMetadata.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Object/ObjCMetadata/ObjCMetadata.h"
+
+using namespace llvm;
+
+Expected<ObjCClass> ObjCClassRef::getObjCClass() const {
+  return MetadataReader->getObjCClassFromRef(*this);
+}
+
+Expected<ObjCCategory> ObjCCategoryRef::getObjCCategory() const {
+  return MetadataReader->getObjCCategoryFromRef(*this);
+}
+
+Expected<ObjCProtocol> ObjCProtocolRef::getObjCProtocol() const {
+  return MetadataReader->getObjCProtocolFromRef(*this);
+}
+
+Expected<StringRef> ObjCClass::getName() const {
+  return MetadataReader->getObjCClassName(*this);
+}
+
+Expected<StringRef> ObjCClassRef::getClassName() const {
+  if (MetadataReader->isObjCClassExternal(*this)) {
+    StringRef symName = MetadataReader->getSymbolNameFromRef(Data);
+    return MetadataReader->guessClassNameBasedOnSymbol(symName);
+  } else if (auto class_t = getObjCClass())
+    return class_t->getName();
+  else
+    return class_t.takeError();
+}
+
+bool ObjCClassRef::isExternal() const {
+  return MetadataReader->isObjCClassExternal(*this);
+}
+
+Expected<StringRef> ObjCClass::getSuperClassName() const {
+  return MetadataReader->getObjCSuperClassName(*this);
+}
+
+Expected<bool> ObjCClass::isSwift() const {
+  return MetadataReader->isObjCClassSwift(*this);
+}
+
+Expected<bool> ObjCClass::isMetaClass() const {
+  return MetadataReader->isObjCClassMetaClass(*this);
+}
+
+Expected<ObjCPropertyList> ObjCClass::properties() const {
+  return MetadataReader->materializePropertyList(*this);
+}
+
+Expected<ObjCPropertyList> ObjCClass::classProperties() const {
+  return MetadataReader->materializeClassPropertyList(*this);
+}
+
+Expected<ObjCMethodList> ObjCClass::instanceMethods() const {
+  return MetadataReader->materializeInstanceMethodList(*this);
+}
+
+Expected<ObjCMethodList> ObjCClass::classMethods() const {
+  return MetadataReader->materializeClassMethodList(*this);
+}
+
+Expected<StringRef> ObjCCategory::getName() const {
+  return MetadataReader->getObjCCategoryName(*this);
+}
+
+Expected<StringRef> ObjCCategory::getBaseClassName() const {
+  return MetadataReader->getObjCCategoryBaseClassName(*this);
+}
+
+Expected<ObjCPropertyList> ObjCCategory::properties() const {
+  return MetadataReader->materializePropertyList(*this);
+}
+
+Expected<ObjCMethodList> ObjCCategory::instanceMethods() const {
+  return MetadataReader->materializeInstanceMethodList(*this);
+}
+
+Expected<ObjCMethodList> ObjCCategory::classMethods() const {
+  return MetadataReader->materializeClassMethodList(*this);
+}
+
+Expected<StringRef> ObjCProtocol::getName() const {
+  return MetadataReader->getObjCProtocolName(*this);
+}
+
+Expected<ObjCPropertyList> ObjCProtocol::properties() const {
+  return MetadataReader->materializePropertyList(*this);
+}
+
+Expected<ObjCMethodList> ObjCProtocol::instanceMethods() const {
+  return MetadataReader->materializeInstanceMethodList(*this);
+}
+
+Expected<ObjCMethodList> ObjCProtocol::classMethods() const {
+  return MetadataReader->materializeClassMethodList(*this);
+}
+
+Expected<ObjCMethodList> ObjCProtocol::optionalInstanceMethods() const {
+  return MetadataReader->materializeOptionalInstanceMethodList(*this);
+}
+
+Expected<ObjCMethodList> ObjCProtocol::optionalClassMethods() const {
+  return MetadataReader->materializeOptionalClassMethodList(*this);
+}
+
+Expected<StringRef> ObjCProperty::getName() const {
+  return MetadataReader->getPropertyName(*this);
+}
+
+Expected<StringRef> ObjCProperty::getAttribute() const {
+  return MetadataReader->getPropertyAttribute(*this);
+}
+
+Expected<bool> ObjCProperty::isDynamic() const {
+  auto Attr = getAttribute();
+  if (!Attr)
+    return Attr.takeError();
+  // Find @dynamic attribute.
+  SmallVector<StringRef, 4> Attrs;
+  Attr->split(Attrs, ',');
+  for (auto a : Attrs) {
+    if (a == "D")
+      return true;
+  }
+  return false;
+}
+
+Expected<std::string> ObjCProperty::getGetter() const {
+  auto Name = getName();
+  if (!Name)
+    return Name.takeError();
+  if (*Name == "#EncryptedString#")
+    return *Name;
+  auto Attr = getAttribute();
+  if (!Attr)
+    return Attr.takeError();
+  // Find getter attribute.
+  SmallVector<StringRef, 4> Attrs;
+  Attr->split(Attrs, ',');
+  for (auto a : Attrs) {
+    if (a.startswith("G"))
+      return a.drop_front(1).str();
+  }
+  // Otherwise returns property name.
+  return Name->str();
+}
+
+Expected<std::string> ObjCProperty::getSetter() const {
+  auto Name = getName();
+  if (!Name)
+    return Name.takeError();
+  if (*Name == "#EncryptedString#")
+    return *Name;
+  auto Attr = getAttribute();
+  if (!Attr)
+    return Attr.takeError();
+  // Find setter attribute.
+  SmallVector<StringRef, 4> Attrs;
+  Attr->split(Attrs, ',');
+  for (auto a : Attrs) {
+    if (a.startswith("S"))
+      return a.drop_front(1).str();
+    else if (a.startswith("R"))
+      return std::string(); // Read-only property
+  }
+  // Otherwise returns property name.
+  std::string setter =
+      "set" + Name->substr(0, 1).upper() + Name->substr(1).str() + ":";
+  return setter;
+}
+
+Expected<StringRef> ObjCMethod::getName() const {
+  return MetadataReader->getMethodName(*this);
+}
+
+Expected<StringRef> ObjCMethod::getType() const {
+  return MetadataReader->getMethodType(*this);
+}
+
+Expected<StringRef> ObjCSelectorRef::getSelector() const {
+  return MetadataReader->getObjCSelectorName(*this);
+}
+
+Expected<StringRef>
+ObjCMetaDataReader::convertSwiftVersion(unsigned raw) const {
+  switch (raw) {
+  case 0:
+    return "";
+  case 1:
+    return "1.0";
+  case 2:
+    return "1.1";
+  case 3:
+    return "2.0";
+  case 4:
+    return "3.0";
+  case 5:
+    return "4.0";
+  case 6:
+    return "4.1";
+  default:
+    return "Unknown future swift version";
+  }
+}

llvm/lib/Object/ObjCMetadata/macho-objc.h

+//===- macho-objc.h - Objective-C runtime for macho -------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_OBJCMETADATA_MACHO_OBJ_H
+#define LLVM_LIB_OBJCMETADATA_MACHO_OBJ_H
+
+#include <llvm/Support/SwapByteOrder.h>
+
+// These are structs in the Objective-C meta data and read to produce the
+// comments for disassembly.  While these are part of the ABI they are no
+// public defintions.  So the are here not in include/llvm/Support/MachO.h .
+
+// The cfstring object in a 64-bit Mach-O file.
+struct cfstring64_t {
+  uint64_t isa;        // class64_t * (64-bit pointer)
+  uint64_t flags;      // flag bits
+  uint64_t characters; // char * (64-bit pointer)
+  uint64_t length;     // number of non-NULL characters in above
+};
+
+// The class object in a 64-bit Mach-O file.
+struct class64_t {
+  uint64_t isa;        // class64_t * (64-bit pointer)
+  uint64_t superclass; // class64_t * (64-bit pointer)
+  uint64_t cache;      // Cache (64-bit pointer)
+  uint64_t vtable;     // IMP * (64-bit pointer)
+  uint64_t data;       // class_ro64_t * (64-bit pointer)
+};
+
+struct class32_t {
+  uint32_t isa;        /* class32_t * (32-bit pointer) */
+  uint32_t superclass; /* class32_t * (32-bit pointer) */
+  uint32_t cache;      /* Cache (32-bit pointer) */
+  uint32_t vtable;     /* IMP * (32-bit pointer) */
+  uint32_t data;       /* class_ro32_t * (32-bit pointer) */
+};
+
+struct class_ro64_t {
+  uint32_t flags;
+  uint32_t instanceStart;
+  uint32_t instanceSize;
+  uint32_t reserved;
+  uint64_t ivarLayout;     // const uint8_t * (64-bit pointer)
+  uint64_t name;           // const char * (64-bit pointer)
+  uint64_t baseMethods;    // const method_list_t * (64-bit pointer)
+  uint64_t baseProtocols;  // const protocol_list_t * (64-bit pointer)
+  uint64_t ivars;          // const ivar_list_t * (64-bit pointer)
+  uint64_t weakIvarLayout; // const uint8_t * (64-bit pointer)
+  uint64_t baseProperties; // const struct objc_property_list (64-bit pointer)
+};
+
+struct class_ro32_t {
+  uint32_t flags;
+  uint32_t instanceStart;
+  uint32_t instanceSize;
+  uint32_t ivarLayout;     /* const uint8_t * (32-bit pointer) */
+  uint32_t name;           /* const char * (32-bit pointer) */
+  uint32_t baseMethods;    /* const method_list_t * (32-bit pointer) */
+  uint32_t baseProtocols;  /* const protocol_list_t * (32-bit pointer) */
+  uint32_t ivars;          /* const ivar_list_t * (32-bit pointer) */
+  uint32_t weakIvarLayout; /* const uint8_t * (32-bit pointer) */
+  uint32_t baseProperties; /* const struct objc_property_list *
+                                                   (32-bit pointer) */
+};
+
+/* Values for class_ro{64,32}_t->flags */
+#define RO_META (1 << 0)
+#define RO_ROOT (1 << 1)
+#define RO_HAS_CXX_STRUCTORS (1 << 2)
+
+struct method_list64_t {
+  uint32_t entsize;
+  uint32_t count;
+  /* struct method64_t first;  These structures follow inline */
+};
+
+struct method_list32_t {
+  uint32_t entsize;
+  uint32_t count;
+  /* struct method32_t first;  These structures follow inline */
+};
+
+struct method64_t {
+  uint64_t name;  /* SEL (64-bit pointer) */
+  uint64_t types; /* const char * (64-bit pointer) */
+  uint64_t imp;   /* IMP (64-bit pointer) */
+};
+
+struct method32_t {
+  uint32_t name;  /* SEL (32-bit pointer) */
+  uint32_t types; /* const char * (32-bit pointer) */
+  uint32_t imp;   /* IMP (32-bit pointer) */
+};
+
+struct protocol_list64_t {
+  uint64_t count; /* uintptr_t (a 64-bit value) */
+  /* struct protocol64_t * list[0];  These pointers follow inline */
+};
+
+struct protocol_list32_t {
+  uint32_t count; /* uintptr_t (a 32-bit value) */
+  /* struct protocol32_t * list[0];  These pointers follow inline */
+};
+
+struct protocol64_t {
+  uint64_t isa;                     /* id * (64-bit pointer) */
+  uint64_t name;                    /* const char * (64-bit pointer) */
+  uint64_t protocols;               /* struct protocol_list64_t *
+                                                    (64-bit pointer) */
+  uint64_t instanceMethods;         /* method_list_t * (64-bit pointer) */
+  uint64_t classMethods;            /* method_list_t * (64-bit pointer) */
+  uint64_t optionalInstanceMethods; /* method_list_t * (64-bit pointer) */
+  uint64_t optionalClassMethods;    /* method_list_t * (64-bit pointer) */
+  uint64_t instanceProperties;      /* struct objc_property_list *
+                                                       (64-bit pointer) */
+};
+
+struct protocol32_t {
+  uint32_t isa;                     /* id * (32-bit pointer) */
+  uint32_t name;                    /* const char * (32-bit pointer) */
+  uint32_t protocols;               /* struct protocol_list_t *
+                                                    (32-bit pointer) */
+  uint32_t instanceMethods;         /* method_list_t * (32-bit pointer) */
+  uint32_t classMethods;            /* method_list_t * (32-bit pointer) */
+  uint32_t optionalInstanceMethods; /* method_list_t * (32-bit pointer) */
+  uint32_t optionalClassMethods;    /* method_list_t * (32-bit pointer) */
+  uint32_t instanceProperties;      /* struct objc_property_list *
+                                                       (32-bit pointer) */
+};
+
+struct ivar_list64_t {
+  uint32_t entsize;
+  uint32_t count;
+  /* struct ivar64_t first;  These structures follow inline */
+};
+
+struct ivar_list32_t {
+  uint32_t entsize;
+  uint32_t count;
+  /* struct ivar32_t first;  These structures follow inline */
+};
+
+struct ivar64_t {
+  uint64_t offset; /* uintptr_t * (64-bit pointer) */
+  uint64_t name;   /* const char * (64-bit pointer) */
+  uint64_t type;   /* const char * (64-bit pointer) */
+  uint32_t alignment;
+  uint32_t size;
+};
+
+struct ivar32_t {
+  uint32_t offset; /* uintptr_t * (32-bit pointer) */
+  uint32_t name;   /* const char * (32-bit pointer) */
+  uint32_t type;   /* const char * (32-bit pointer) */
+  uint32_t alignment;
+  uint32_t size;
+};
+
+struct objc_property_list64 {
+  uint32_t entsize;
+  uint32_t count;
+  /* struct objc_property64 first;  These structures follow inline */
+};
+
+struct objc_property_list32 {
+  uint32_t entsize;
+  uint32_t count;
+  /* struct objc_property32 first;  These structures follow inline */
+};
+
+struct objc_property64 {
+  uint64_t name;       /* const char * (64-bit pointer) */
+  uint64_t attributes; /* const char * (64-bit pointer) */
+};
+
+struct objc_property32 {
+  uint32_t name;       /* const char * (32-bit pointer) */
+  uint32_t attributes; /* const char * (32-bit pointer) */
+};
+
+struct category64_t {
+  uint64_t name;               /* const char * (64-bit pointer) */
+  uint64_t cls;                /* struct class_t * (64-bit pointer) */
+  uint64_t instanceMethods;    /* struct method_list_t * (64-bit pointer) */
+  uint64_t classMethods;       /* struct method_list_t * (64-bit pointer) */
+  uint64_t protocols;          /* struct protocol_list_t * (64-bit pointer) */
+  uint64_t instanceProperties; /* struct objc_property_list *
+                                  (64-bit pointer) */
+};
+
+struct category32_t {
+  uint32_t name;               /* const char * (32-bit pointer) */
+  uint32_t cls;                /* struct class_t * (32-bit pointer) */
+  uint32_t instanceMethods;    /* struct method_list_t * (32-bit pointer) */
+  uint32_t classMethods;       /* struct method_list_t * (32-bit pointer) */
+  uint32_t protocols;          /* struct protocol_list_t * (32-bit pointer) */
+  uint32_t instanceProperties; /* struct objc_property_list *
+                                  (32-bit pointer) */
+};
+
+struct objc_image_info64 {
+  uint32_t version;
+  uint32_t flags;
+};
+struct objc_image_info32 {
+  uint32_t version;
+  uint32_t flags;
+};
+struct imageInfo_t {
+  uint32_t version;
+  uint32_t flags;
+};
+/* masks for objc_image_info.flags */
+#define OBJC_IMAGE_IS_REPLACEMENT (1 << 0)
+#define OBJC_IMAGE_SUPPORTS_GC (1 << 1)
+
+struct message_ref64 {
+  uint64_t imp; /* IMP (64-bit pointer) */
+  uint64_t sel; /* SEL (64-bit pointer) */
+};
+
+struct message_ref32 {
+  uint32_t imp; /* IMP (32-bit pointer) */
+  uint32_t sel; /* SEL (32-bit pointer) */
+};
+
+// Objective-C 1 (32-bit only) meta data structs.
+
+struct objc_module_t {
+  uint32_t version;
+  uint32_t size;
+  uint32_t name;   /* char * (32-bit pointer) */
+  uint32_t symtab; /* struct objc_symtab * (32-bit pointer) */
+};
+
+struct objc_symtab_t {
+  uint32_t sel_ref_cnt;
+  uint32_t refs; /* SEL * (32-bit pointer) */
+  uint16_t cls_def_cnt;
+  uint16_t cat_def_cnt;
+  // uint32_t defs[1];        /* void * (32-bit pointer) variable size */
+};
+
+struct objc_class_t {
+  uint32_t isa;         /* struct objc_class * (32-bit pointer) */
+  uint32_t super_class; /* struct objc_class * (32-bit pointer) */
+  uint32_t name;        /* const char * (32-bit pointer) */
+  int32_t version;
+  int32_t info;
+  int32_t instance_size;
+  uint32_t ivars;       /* struct objc_ivar_list * (32-bit pointer) */
+  uint32_t methodLists; /* struct objc_method_list ** (32-bit pointer) */
+  uint32_t cache;       /* struct objc_cache * (32-bit pointer) */
+  uint32_t protocols;   /* struct objc_protocol_list * (32-bit pointer) */
+};
+
+#define CLS_GETINFO(cls, infomask) ((cls)->info & (infomask))
+// class is not a metaclass
+#define CLS_CLASS 0x1
+// class is a metaclass
+#define CLS_META 0x2
+
+struct objc_category_t {
+  uint32_t category_name;    /* char * (32-bit pointer) */
+  uint32_t class_name;       /* char * (32-bit pointer) */
+  uint32_t instance_methods; /* struct objc_method_list * (32-bit pointer) */
+  uint32_t class_methods;    /* struct objc_method_list * (32-bit pointer) */
+  uint32_t protocols;        /* struct objc_protocol_list * (32-bit ptr) */
+};
+
+struct objc_ivar_t {
+  uint32_t ivar_name; /* char * (32-bit pointer) */
+  uint32_t ivar_type; /* char * (32-bit pointer) */
+  int32_t ivar_offset;
+};
+
+struct objc_ivar_list_t {
+  int32_t ivar_count;
+  // struct objc_ivar_t ivar_list[1];          /* variable length structure */
+};
+
+struct objc_method_list_t {
+  uint32_t obsolete; /* struct objc_method_list * (32-bit pointer) */
+  int32_t method_count;
+  // struct objc_method_t method_list[1];      /* variable length structure */
+};
+
+struct objc_method_t {
+  uint32_t method_name;  /* SEL, aka struct objc_selector * (32-bit pointer) */
+  uint32_t method_types; /* char * (32-bit pointer) */
+  uint32_t method_imp;   /* IMP, aka function pointer, (*IMP)(id, SEL, ...)
+                            (32-bit pointer) */
+};
+
+struct objc_protocol_list_t {
+  uint32_t next; /* struct objc_protocol_list * (32-bit pointer) */
+  int32_t count;
+  // uint32_t list[1];   /* Protocol *, aka struct objc_protocol_t *
+  //                        (32-bit pointer) */
+};
+
+struct objc_protocol_t {
+  uint32_t isa;              /* struct objc_class * (32-bit pointer) */
+  uint32_t protocol_name;    /* char * (32-bit pointer) */
+  uint32_t protocol_list;    /* struct objc_protocol_list * (32-bit pointer) */
+  uint32_t instance_methods; /* struct objc_method_description_list *
+                                (32-bit pointer) */
+  uint32_t class_methods;    /* struct objc_method_description_list *
+                                (32-bit pointer) */
+};
+
+struct objc_method_description_list_t {
+  int32_t count;
+  // struct objc_method_description_t list[1];
+};
+
+struct objc_method_description_t {
+  uint32_t name;  /* SEL, aka struct objc_selector * (32-bit pointer) */
+  uint32_t types; /* char * (32-bit pointer) */
+};
+
+inline void swapStruct(struct cfstring64_t &cfs) {
+  llvm::sys::swapByteOrder(cfs.isa);
+  llvm::sys::swapByteOrder(cfs.flags);
+  llvm::sys::swapByteOrder(cfs.characters);
+  llvm::sys::swapByteOrder(cfs.length);
+}
+
+inline void swapStruct(struct class64_t &c) {
+  llvm::sys::swapByteOrder(c.isa);
+  llvm::sys::swapByteOrder(c.superclass);
+  llvm::sys::swapByteOrder(c.cache);
+  llvm::sys::swapByteOrder(c.vtable);
+  llvm::sys::swapByteOrder(c.data);
+}
+
+inline void swapStruct(struct class32_t &c) {
+  llvm::sys::swapByteOrder(c.isa);
+  llvm::sys::swapByteOrder(c.superclass);
+  llvm::sys::swapByteOrder(c.cache);
+  llvm::sys::swapByteOrder(c.vtable);
+  llvm::sys::swapByteOrder(c.data);
+}
+
+inline void swapStruct(struct class_ro64_t &cro) {
+  llvm::sys::swapByteOrder(cro.flags);
+  llvm::sys::swapByteOrder(cro.instanceStart);
+  llvm::sys::swapByteOrder(cro.instanceSize);
+  llvm::sys::swapByteOrder(cro.reserved);
+  llvm::sys::swapByteOrder(cro.ivarLayout);
+  llvm::sys::swapByteOrder(cro.name);
+  llvm::sys::swapByteOrder(cro.baseMethods);
+  llvm::sys::swapByteOrder(cro.baseProtocols);
+  llvm::sys::swapByteOrder(cro.ivars);
+  llvm::sys::swapByteOrder(cro.weakIvarLayout);
+  llvm::sys::swapByteOrder(cro.baseProperties);
+}
+
+inline void swapStruct(struct class_ro32_t &cro) {
+  llvm::sys::swapByteOrder(cro.flags);
+  llvm::sys::swapByteOrder(cro.instanceStart);
+  llvm::sys::swapByteOrder(cro.instanceSize);
+  llvm::sys::swapByteOrder(cro.ivarLayout);
+  llvm::sys::swapByteOrder(cro.name);
+  llvm::sys::swapByteOrder(cro.baseMethods);
+  llvm::sys::swapByteOrder(cro.baseProtocols);
+  llvm::sys::swapByteOrder(cro.ivars);
+  llvm::sys::swapByteOrder(cro.weakIvarLayout);
+  llvm::sys::swapByteOrder(cro.baseProperties);
+}
+
+inline void swapStruct(struct method_list64_t &ml) {
+  llvm::sys::swapByteOrder(ml.entsize);
+  llvm::sys::swapByteOrder(ml.count);
+}
+
+inline void swapStruct(struct method_list32_t &ml) {
+  llvm::sys::swapByteOrder(ml.entsize);
+  llvm::sys::swapByteOrder(ml.count);
+}
+
+inline void swapStruct(struct method64_t &m) {
+  llvm::sys::swapByteOrder(m.name);
+  llvm::sys::swapByteOrder(m.types);
+  llvm::sys::swapByteOrder(m.imp);
+}
+
+inline void swapStruct(struct method32_t &m) {
+  llvm::sys::swapByteOrder(m.name);
+  llvm::sys::swapByteOrder(m.types);
+  llvm::sys::swapByteOrder(m.imp);
+}
+
+inline void swapStruct(struct protocol_list64_t &pl) {
+  llvm::sys::swapByteOrder(pl.count);
+}
+
+inline void swapStruct(struct protocol_list32_t &pl) {
+  llvm::sys::swapByteOrder(pl.count);
+}
+
+inline void swapStruct(struct protocol64_t &p) {
+  llvm::sys::swapByteOrder(p.isa);
+  llvm::sys::swapByteOrder(p.name);
+  llvm::sys::swapByteOrder(p.protocols);
+  llvm::sys::swapByteOrder(p.instanceMethods);
+  llvm::sys::swapByteOrder(p.classMethods);
+  llvm::sys::swapByteOrder(p.optionalInstanceMethods);
+  llvm::sys::swapByteOrder(p.optionalClassMethods);
+  llvm::sys::swapByteOrder(p.instanceProperties);
+}
+
+inline void swapStruct(struct protocol32_t &p) {
+  llvm::sys::swapByteOrder(p.isa);
+  llvm::sys::swapByteOrder(p.name);
+  llvm::sys::swapByteOrder(p.protocols);
+  llvm::sys::swapByteOrder(p.instanceMethods);
+  llvm::sys::swapByteOrder(p.classMethods);
+  llvm::sys::swapByteOrder(p.optionalInstanceMethods);
+  llvm::sys::swapByteOrder(p.optionalClassMethods);
+  llvm::sys::swapByteOrder(p.instanceProperties);
+}
+
+inline void swapStruct(struct ivar_list64_t &il) {
+  llvm::sys::swapByteOrder(il.entsize);
+  llvm::sys::swapByteOrder(il.count);
+}
+
+inline void swapStruct(struct ivar_list32_t &il) {
+  llvm::sys::swapByteOrder(il.entsize);
+  llvm::sys::swapByteOrder(il.count);
+}
+
+inline void swapStruct(struct ivar64_t &i) {
+  llvm::sys::swapByteOrder(i.offset);
+  llvm::sys::swapByteOrder(i.name);
+  llvm::sys::swapByteOrder(i.type);
+  llvm::sys::swapByteOrder(i.alignment);
+  llvm::sys::swapByteOrder(i.size);
+}
+
+inline void swapStruct(struct ivar32_t &i) {
+  llvm::sys::swapByteOrder(i.offset);
+  llvm::sys::swapByteOrder(i.name);
+  llvm::sys::swapByteOrder(i.type);
+  llvm::sys::swapByteOrder(i.alignment);
+  llvm::sys::swapByteOrder(i.size);
+}
+
+inline void swapStruct(struct objc_property_list64 &pl) {
+  llvm::sys::swapByteOrder(pl.entsize);
+  llvm::sys::swapByteOrder(pl.count);
+}
+
+inline void swapStruct(struct objc_property_list32 &pl) {
+  llvm::sys::swapByteOrder(pl.entsize);
+  llvm::sys::swapByteOrder(pl.count);
+}
+
+inline void swapStruct(struct objc_property64 &op) {
+  llvm::sys::swapByteOrder(op.name);
+  llvm::sys::swapByteOrder(op.attributes);
+}
+
+inline void swapStruct(struct objc_property32 &op) {
+  llvm::sys::swapByteOrder(op.name);
+  llvm::sys::swapByteOrder(op.attributes);
+}
+
+inline void swapStruct(struct category64_t &c) {
+  llvm::sys::swapByteOrder(c.name);
+  llvm::sys::swapByteOrder(c.cls);
+  llvm::sys::swapByteOrder(c.instanceMethods);
+  llvm::sys::swapByteOrder(c.classMethods);
+  llvm::sys::swapByteOrder(c.protocols);
+  llvm::sys::swapByteOrder(c.instanceProperties);
+}
+
+inline void swapStruct(struct category32_t &c) {
+  llvm::sys::swapByteOrder(c.name);
+  llvm::sys::swapByteOrder(c.cls);
+  llvm::sys::swapByteOrder(c.instanceMethods);
+  llvm::sys::swapByteOrder(c.classMethods);
+  llvm::sys::swapByteOrder(c.protocols);
+  llvm::sys::swapByteOrder(c.instanceProperties);
+}
+
+inline void swapStruct(struct objc_image_info64 &o) {
+  llvm::sys::swapByteOrder(o.version);
+  llvm::sys::swapByteOrder(o.flags);
+}
+
+inline void swapStruct(struct objc_image_info32 &o) {
+  llvm::sys::swapByteOrder(o.version);
+  llvm::sys::swapByteOrder(o.flags);
+}
+
+inline void swapStruct(struct imageInfo_t &o) {
+  llvm::sys::swapByteOrder(o.version);
+  llvm::sys::swapByteOrder(o.flags);
+}
+
+inline void swapStruct(struct message_ref64 &mr) {
+  llvm::sys::swapByteOrder(mr.imp);
+  llvm::sys::swapByteOrder(mr.sel);
+}
+
+inline void swapStruct(struct message_ref32 &mr) {
+  llvm::sys::swapByteOrder(mr.imp);
+  llvm::sys::swapByteOrder(mr.sel);
+}
+
+inline void swapStruct(struct objc_module_t &module) {
+  llvm::sys::swapByteOrder(module.version);
+  llvm::sys::swapByteOrder(module.size);
+  llvm::sys::swapByteOrder(module.name);
+  llvm::sys::swapByteOrder(module.symtab);
+}
+
+inline void swapStruct(struct objc_symtab_t &symtab) {
+  llvm::sys::swapByteOrder(symtab.sel_ref_cnt);
+  llvm::sys::swapByteOrder(symtab.refs);
+  llvm::sys::swapByteOrder(symtab.cls_def_cnt);
+  llvm::sys::swapByteOrder(symtab.cat_def_cnt);
+}
+
+inline void swapStruct(struct objc_class_t &objc_class) {
+  llvm::sys::swapByteOrder(objc_class.isa);
+  llvm::sys::swapByteOrder(objc_class.super_class);
+  llvm::sys::swapByteOrder(objc_class.name);
+  llvm::sys::swapByteOrder(objc_class.version);
+  llvm::sys::swapByteOrder(objc_class.info);
+  llvm::sys::swapByteOrder(objc_class.instance_size);
+  llvm::sys::swapByteOrder(objc_class.ivars);
+  llvm::sys::swapByteOrder(objc_class.methodLists);
+  llvm::sys::swapByteOrder(objc_class.cache);
+  llvm::sys::swapByteOrder(objc_class.protocols);
+}
+
+inline void swapStruct(struct objc_category_t &objc_category) {
+  llvm::sys::swapByteOrder(objc_category.category_name);
+  llvm::sys::swapByteOrder(objc_category.class_name);
+  llvm::sys::swapByteOrder(objc_category.instance_methods);
+  llvm::sys::swapByteOrder(objc_category.class_methods);
+  llvm::sys::swapByteOrder(objc_category.protocols);
+}
+
+inline void swapStruct(struct objc_ivar_list_t &objc_ivar_list) {
+  llvm::sys::swapByteOrder(objc_ivar_list.ivar_count);
+}
+
+inline void swapStruct(struct objc_ivar_t &objc_ivar) {
+  llvm::sys::swapByteOrder(objc_ivar.ivar_name);
+  llvm::sys::swapByteOrder(objc_ivar.ivar_type);
+  llvm::sys::swapByteOrder(objc_ivar.ivar_offset);
+}
+
+inline void swapStruct(struct objc_method_list_t &method_list) {
+  llvm::sys::swapByteOrder(method_list.obsolete);
+  llvm::sys::swapByteOrder(method_list.method_count);
+}
+
+inline void swapStruct(struct objc_method_t &method) {
+  llvm::sys::swapByteOrder(method.method_name);
+  llvm::sys::swapByteOrder(method.method_types);
+  llvm::sys::swapByteOrder(method.method_imp);
+}
+
+inline void swapStruct(struct objc_protocol_list_t &protocol_list) {
+  llvm::sys::swapByteOrder(protocol_list.next);
+  llvm::sys::swapByteOrder(protocol_list.count);
+}
+
+inline void swapStruct(struct objc_protocol_t &protocol) {
+  llvm::sys::swapByteOrder(protocol.isa);
+  llvm::sys::swapByteOrder(protocol.protocol_name);
+  llvm::sys::swapByteOrder(protocol.protocol_list);
+  llvm::sys::swapByteOrder(protocol.instance_methods);
+  llvm::sys::swapByteOrder(protocol.class_methods);
+}
+
+inline void swapStruct(struct objc_method_description_list_t &mdl) {
+  llvm::sys::swapByteOrder(mdl.count);
+}
+
+inline void swapStruct(struct objc_method_description_t &md) {
+  llvm::sys::swapByteOrder(md.name);
+  llvm::sys::swapByteOrder(md.types);
+}
+
+#endif

llvm/test/CMakeLists.txt

set(LLVM_TEST_DEPENDS
           llvm-link
           llvm-lto2
           llvm-mc
           llvm-mca
           llvm-modextract
           llvm-mt
           llvm-nm
           llvm-objcopy
+          llvm-objc-metadata
           llvm-objdump
           llvm-opt-fuzzer
           llvm-opt-report
           llvm-pdbutil
           llvm-profdata
           llvm-ranlib
           llvm-rc
           llvm-readobj

llvm/test/Object/ObjCMetadata/linked_binary.test

+; RUN: llvm-objc-metadata %S/Inputs/libtest.dylib
+; CHECK: Objective-C Classes:
+; CHECK: # A :
+; CHECK:   instance method: catMethod3
+; CHECK:   instance method: catMethod1
+; CHECK:   instance method: catMethod3:
+; CHECK:   instance method: meth1
+; CHECK:   instance method: meth2:
+; CHECK:   instance method: prop1
+; CHECK:   instance method: setProp1:
+; CHECK:   instance method: prop2
+; CHECK:   instance method: isProp3
+; CHECK:   instance method: setProp3:
+; CHECK:   instance method: prop4
+; CHECK:   instance method: prop4To:
+; CHECK:   class method: catMethod2
+; CHECK:   class method: meth3
+; CHECK:   class method: meth4:
+; CHECK:   property: cp1
+; CHECK:   property: cp2
+; CHECK:   property: prop1
+; CHECK:   property: prop2
+; CHECK:   property: prop3
+; CHECK:   property: prop4
+; CHECK:   class property: prop5
+; CHECK: # B : A
+; CHECK:   instance method: method
+; CHECK: # PA : A
+; CHECK:   instance method: protoMethod1
+; CHECK:   instance method: protoMethod2:
+; CHECK:   class method: protoMethod3
+; CHECK:   property: pp1
+; CHECK:   property: pp2
+; CHECK: # PB : E
+; CHECK:   instance method: protoMethod7
+; CHECK: # E :
+; CHECK:   instance method: external
+; CHECK: Objective-C Protocols:
+; CHECK: # P
+; CHECK:   instance method: protoMethod1
+; CHECK:   instance method: protoMethod2:
+; CHECK:   instance method: pp1
+; CHECK:   instance method: setPp1:
+; CHECK:   instance method: pp2
+; CHECK:   instance method: setPp2:
+; CHECK:   optional instance method: protoMethod4
+; CHECK:   optional instance method: protoMethod5:
+; CHECK:   class method: protoMethod3
+; CHECK:   optional class method: protoMethod6
+; CHECK:   property: pp1
+; CHECK:   property: pp2
+; CHECK: # P2
+; CHECK:   instance method: protoMethod7
+; CHECK: Objective-C Categories:

llvm/test/Object/ObjCMetadata/lit.local.cfg

+if 'AArch64' not in config.root.targets or 'X86' not in config.root.targets:
+    config.unsupported = True

llvm/test/Object/ObjCMetadata/new-objc-segment.ll

+; RUN: llvm-objc-metadata %s | FileCheck %s
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: llvm-objc-metadata %t.o | FileCheck %s
+
+; CHECK: Objective-C Classes:
+; CHECK: # A :
+; CHECK:   instance method: meth1
+; CHECK:   instance method: meth2:
+; CHECK:   instance method: prop1
+; CHECK:   instance method: setProp1:
+; CHECK:   instance method: prop2
+; CHECK:   instance method: isProp3
+; CHECK:   instance method: setProp3:
+; CHECK:   instance method: prop4
+; CHECK:   instance method: prop4To:
+; CHECK:   class method: meth3
+; CHECK:   class method: meth4:
+; CHECK:   property: prop1
+; CHECK:   property: prop2
+; CHECK:   property: prop3
+; CHECK:   property: prop4
+; CHECK: # B : A
+; CHECK:   instance method: method
+; CHECK: # PA : A
+; CHECK:   instance method: protoMethod1
+; CHECK:   instance method: protoMethod2:
+; CHECK:   class method: protoMethod3
+; CHECK:   property: pp1
+; CHECK:   property: pp2
+; CHECK: # PB : E
+; CHECK:   instance method: protoMethod7
+; CHECK: Objective-C Protocols:
+; CHECK: # P
+; CHECK:   instance method: protoMethod1
+; CHECK:   instance method: protoMethod2:
+; CHECK:   instance method: pp1
+; CHECK:   instance method: setPp1:
+; CHECK:   instance method: pp2
+; CHECK:   instance method: setPp2:
+; CHECK:   optional instance method: protoMethod4
+; CHECK:   optional instance method: protoMethod5:
+; CHECK:   class method: protoMethod3
+; CHECK:   optional class method: protoMethod6
+; CHECK:   property: pp1
+; CHECK:   property: pp2
+; CHECK: # P2
+; CHECK:   instance method: protoMethod7
+; CHECK: Objective-C Categories:
+; CHECK: # A(C)
+; CHECK:   instance method: catMethod1
+; CHECK:   instance method: catMethod3:
+; CHECK:   class method: catMethod2
+; CHECK:   property: cp1
+; CHECK:   property: cp2
+; CHECK: # A(C1)
+; CHECK:   instance method: catMethod3
+
+; ModuleID = 'objc-metadata.m'
+source_filename = "objc-metadata.m"
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.12.0"
+
+%0 = type opaque
+%1 = type opaque
+%2 = type opaque
+%3 = type opaque
+%4 = type opaque
+%struct._objc_cache = type opaque
+%struct._class_t = type { %struct._class_t*, %struct._class_t*, %struct._objc_cache*, i8* (i8*, i8*)**, %struct._class_ro_t* }
+%struct._class_ro_t = type { i32, i32, i32, i8*, i8*, %struct.__method_list_t*, %struct._objc_protocol_list*, %struct._ivar_list_t*, i8*, %struct._prop_list_t* }
+%struct.__method_list_t = type { i32, i32, [0 x %struct._objc_method] }
+%struct._objc_method = type { i8*, i8*, i8* }
+%struct._objc_protocol_list = type { i64, [0 x %struct._protocol_t*] }
+%struct._protocol_t = type { i8*, i8*, %struct._objc_protocol_list*, %struct.__method_list_t*, %struct.__method_list_t*, %struct.__method_list_t*, %struct.__method_list_t*, %struct._prop_list_t*, i32, i32, i8**, i8*, %struct._prop_list_t* }
+%struct._ivar_list_t = type { i32, i32, [0 x %struct._ivar_t] }
+%struct._ivar_t = type { i64*, i8*, i8*, i32, i32 }
+%struct._prop_list_t = type { i32, i32, [0 x %struct._prop_t] }
+%struct._prop_t = type { i8*, i8* }
+%struct._category_t = type { i8*, %struct._class_t*, %struct.__method_list_t*, %struct.__method_list_t*, %struct._objc_protocol_list*, %struct._prop_list_t*, %struct._prop_list_t*, i32 }
+
+@OBJC_METH_VAR_NAME_ = private global [6 x i8] c"meth1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_SELECTOR_REFERENCES_ = private externally_initialized global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_, i64 0, i64 0), section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip", align 8
+@OBJC_METH_VAR_NAME_.1 = private global [6 x i8] c"prop1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_SELECTOR_REFERENCES_.2 = private externally_initialized global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.1, i64 0, i64 0), section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip", align 8
+@"OBJC_IVAR_$_A._prop1" = hidden global i64 0, section "__DATA, __objc_ivar", align 8
+@"OBJC_IVAR_$_A._prop2" = hidden global i64 4, section "__DATA, __objc_ivar", align 8
+@"OBJC_IVAR_$_A._prop3" = hidden global i64 8, section "__DATA, __objc_ivar", align 8
+@"OBJC_IVAR_$_A._prop4" = hidden global i64 12, section "__DATA, __objc_ivar", align 8
+@_objc_empty_cache = external global %struct._objc_cache
+@"OBJC_CLASS_$_A" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_A", %struct._class_t* null, %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_CLASS_RO_$_A" }, section "__DATA, __objc_data", align 8
+@"OBJC_METACLASS_$_A" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_A", %struct._class_t* @"OBJC_CLASS_$_A", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_METACLASS_RO_$_A" }, section "__DATA, __objc_data", align 8
+@OBJC_CLASS_NAME_ = private global [2 x i8] c"A\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.3 = private global [6 x i8] c"meth3\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_ = private global [8 x i8] c"v16@0:8\00", section "__TEXT,__objc_methtype,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.4 = private global [7 x i8] c"meth4:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_.5 = private global [11 x i8] c"v20@0:8i16\00", section "__TEXT,__objc_methtype,cstring_literals", align 1
+@"\01l_OBJC_$_CLASS_METHODS_A" = private global { i32, i32, [2 x %struct._objc_method] } { i32 24, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.3, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (i8*, i8*)* @"\01+[A meth3]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.4, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* bitcast (void (i8*, i8*, i32)* @"\01+[A meth4:]" to i8*) }] }, section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_METACLASS_RO_$_A" = private global %struct._class_ro_t { i32 3, i32 40, i32 40, i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_CLASS_METHODS_A" to %struct.__method_list_t*), %struct._objc_protocol_list* null, %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA_CONST, __objc_const", align 8
+@OBJC_METH_VAR_NAME_.6 = private global [7 x i8] c"meth2:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_.7 = private global [8 x i8] c"i16@0:8\00", section "__TEXT,__objc_methtype,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.8 = private global [10 x i8] c"setProp1:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.9 = private global [6 x i8] c"prop2\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.10 = private global [8 x i8] c"isProp3\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.11 = private global [10 x i8] c"setProp3:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.12 = private global [6 x i8] c"prop4\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.13 = private global [9 x i8] c"prop4To:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_INSTANCE_METHODS_A" = private global { i32, i32, [9 x %struct._objc_method] } { i32 24, i32 9, [9 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%0*, i8*)* @"\01-[A meth1]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.6, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* bitcast (void (%0*, i8*, i32)* @"\01-[A meth2:]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.1, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.7, i32 0, i32 0), i8* bitcast (i32 (%0*, i8*)* @"\01-[A prop1]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_NAME_.8, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* bitcast (void (%0*, i8*, i32)* @"\01-[A setProp1:]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.9, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.7, i32 0, i32 0), i8* bitcast (i32 (%0*, i8*)* @"\01-[A prop2]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.10, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.7, i32 0, i32 0), i8* bitcast (i32 (%0*, i8*)* @"\01-[A isProp3]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_NAME_.11, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* bitcast (void (%0*, i8*, i32)* @"\01-[A setProp3:]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.12, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.7, i32 0, i32 0), i8* bitcast (i32 (%0*, i8*)* @"\01-[A prop4]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @OBJC_METH_VAR_NAME_.13, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* bitcast (void (%0*, i8*, i32)* @"\01-[A prop4To:]" to i8*) }] }, section "__DATA_CONST, __objc_const", align 8
+@OBJC_METH_VAR_NAME_.14 = private global [7 x i8] c"_prop1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_.15 = private global [2 x i8] c"i\00", section "__TEXT,__objc_methtype,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.16 = private global [7 x i8] c"_prop2\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.17 = private global [7 x i8] c"_prop3\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.18 = private global [7 x i8] c"_prop4\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_INSTANCE_VARIABLES_A" = private global { i32, i32, [4 x %struct._ivar_t] } { i32 32, i32 4, [4 x %struct._ivar_t] [%struct._ivar_t { i64* @"OBJC_IVAR_$_A._prop1", i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.14, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_METH_VAR_TYPE_.15, i32 0, i32 0), i32 2, i32 4 }, %struct._ivar_t { i64* @"OBJC_IVAR_$_A._prop2", i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.16, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_METH_VAR_TYPE_.15, i32 0, i32 0), i32 2, i32 4 }, %struct._ivar_t { i64* @"OBJC_IVAR_$_A._prop3", i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.17, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_METH_VAR_TYPE_.15, i32 0, i32 0), i32 2, i32 4 }, %struct._ivar_t { i64* @"OBJC_IVAR_$_A._prop4", i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.18, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_METH_VAR_TYPE_.15, i32 0, i32 0), i32 2, i32 4 }] }, section "__DATA_CONST, __objc_const", align 8
+@OBJC_PROP_NAME_ATTR_ = private global [6 x i8] c"prop1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.19 = private global [11 x i8] c"Ti,V_prop1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.20 = private global [6 x i8] c"prop2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.21 = private global [13 x i8] c"Ti,R,V_prop2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.22 = private global [6 x i8] c"prop3\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.23 = private global [20 x i8] c"Ti,GisProp3,V_prop3\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.24 = private global [6 x i8] c"prop4\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.25 = private global [21 x i8] c"Ti,Sprop4To:,V_prop4\00", section "__TEXT,__cstring,cstring_literals", align 1
+@"\01l_OBJC_$_PROP_LIST_A" = private global { i32, i32, [4 x %struct._prop_t] } { i32 16, i32 4, [4 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_PROP_NAME_ATTR_.19, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.20, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_PROP_NAME_ATTR_.21, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.22, i32 0, i32 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @OBJC_PROP_NAME_ATTR_.23, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.24, i32 0, i32 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @OBJC_PROP_NAME_ATTR_.25, i32 0, i32 0) }] }, section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_CLASS_RO_$_A" = private global %struct._class_ro_t { i32 2, i32 0, i32 16, i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [9 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_A" to %struct.__method_list_t*), %struct._objc_protocol_list* null, %struct._ivar_list_t* bitcast ({ i32, i32, [4 x %struct._ivar_t] }* @"\01l_OBJC_$_INSTANCE_VARIABLES_A" to %struct._ivar_list_t*), i8* null, %struct._prop_list_t* bitcast ({ i32, i32, [4 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A" to %struct._prop_list_t*) }, section "__DATA_CONST, __objc_const", align 8
+@OBJC_CLASS_NAME_.26 = private global [2 x i8] c"B\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@"\01l_OBJC_METACLASS_RO_$_B" = private global %struct._class_ro_t { i32 1, i32 40, i32 40, i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.26, i32 0, i32 0), %struct.__method_list_t* null, %struct._objc_protocol_list* null, %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA_CONST, __objc_const", align 8
+@"OBJC_METACLASS_$_B" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_A", %struct._class_t* @"OBJC_METACLASS_$_A", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_METACLASS_RO_$_B" }, section "__DATA, __objc_data", align 8
+@OBJC_METH_VAR_NAME_.27 = private global [7 x i8] c"method\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_INSTANCE_METHODS_B" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.27, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%1*, i8*)* @"\01-[B method]" to i8*) }] }, section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_CLASS_RO_$_B" = private global %struct._class_ro_t { i32 0, i32 16, i32 16, i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.26, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_B" to %struct.__method_list_t*), %struct._objc_protocol_list* null, %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA_CONST, __objc_const", align 8
+@"OBJC_CLASS_$_B" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_B", %struct._class_t* @"OBJC_CLASS_$_A", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_CLASS_RO_$_B" }, section "__DATA, __objc_data", align 8
+@OBJC_METH_VAR_NAME_.28 = private global [9 x i8] c"external\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_SELECTOR_REFERENCES_.29 = private externally_initialized global i8* getelementptr inbounds ([9 x i8], [9 x i8]* @OBJC_METH_VAR_NAME_.28, i64 0, i64 0), section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip", align 8
+@OBJC_CLASS_NAME_.30 = private global [2 x i8] c"C\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.31 = private global [11 x i8] c"catMethod1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.32 = private global [12 x i8] c"catMethod3:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_.33 = private global [11 x i8] c"v24@0:8@16\00", section "__TEXT,__objc_methtype,cstring_literals", align 1
+@"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C" = private global { i32, i32, [2 x %struct._objc_method] } { i32 24, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.31, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%0*, i8*)* @"\01-[A(C) catMethod1]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([12 x i8], [12 x i8]* @OBJC_METH_VAR_NAME_.32, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.33, i32 0, i32 0), i8* bitcast (void (%0*, i8*, %2*)* @"\01-[A(C) catMethod3:]" to i8*) }] }, section "__DATA_CONST, __objc_const", align 8
+@OBJC_METH_VAR_NAME_.34 = private global [11 x i8] c"catMethod2\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_CATEGORY_CLASS_METHODS_A_$_C" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.34, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (i8*, i8*)* @"\01+[A(C) catMethod2]" to i8*) }] }, section "__DATA_CONST, __objc_const", align 8
+@OBJC_PROP_NAME_ATTR_.35 = private global [4 x i8] c"cp1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.36 = private global [5 x i8] c"Ti,D\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.37 = private global [4 x i8] c"cp2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@"\01l_OBJC_$_PROP_LIST_A_$_C" = private global { i32, i32, [2 x %struct._prop_t] } { i32 16, i32 2, [2 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.35, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.36, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.37, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.36, i32 0, i32 0) }] }, section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_$_CATEGORY_A_$_C" = private global %struct._category_t { i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.30, i32 0, i32 0), %struct._class_t* @"OBJC_CLASS_$_A", %struct.__method_list_t* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C" to %struct.__method_list_t*), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_CLASS_METHODS_A_$_C" to %struct.__method_list_t*), %struct._objc_protocol_list* null, %struct._prop_list_t* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A_$_C" to %struct._prop_list_t*), %struct._prop_list_t* null, i32 64 }, section "__DATA_CONST, __objc_const", align 8
+@OBJC_CLASS_NAME_.38 = private global [3 x i8] c"C1\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.39 = private global [11 x i8] c"catMethod3\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C1" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.39, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%0*, i8*)* @"\01-[A(C1) catMethod3]" to i8*) }] }, section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_$_CATEGORY_A_$_C1" = private global %struct._category_t { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.38, i32 0, i32 0), %struct._class_t* @"OBJC_CLASS_$_A", %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C1" to %struct.__method_list_t*), %struct.__method_list_t* null, %struct._objc_protocol_list* null, %struct._prop_list_t* null, %struct._prop_list_t* null, i32 64 }, section "__DATA_CONST, __objc_const", align 8
+@OBJC_CLASS_NAME_.40 = private global [3 x i8] c"PA\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.41 = private global [13 x i8] c"protoMethod3\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_CLASS_METHODS_PA" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.41, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (i8*, i8*)* @"\01+[PA protoMethod3]" to i8*) }] }, section "__DATA_CONST, __objc_const", align 8
+@OBJC_METH_VAR_NAME_.42 = private global [13 x i8] c"protoMethod1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.43 = private global [14 x i8] c"protoMethod2:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.44 = private global [13 x i8] c"protoMethod4\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.45 = private global [14 x i8] c"protoMethod5:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.46 = private global [4 x i8] c"pp1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.47 = private global [8 x i8] c"setPp1:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.48 = private global [4 x i8] c"pp2\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.49 = private global [8 x i8] c"setPp2:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.50 = private global [13 x i8] c"protoMethod6\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_CLASS_NAME_.51 = private global [2 x i8] c"P\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P" = private global { i32, i32, [6 x %struct._objc_method] } { i32 24, i32 6, [6 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.42, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.43, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.33, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.46, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.7, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.47, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.48, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.7, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.49, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* null }] }, section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_P" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.41, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* null }] }, section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_P" = private global { i32, i32, [2 x %struct._objc_method] } { i32 24, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.44, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.45, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.33, i32 0, i32 0), i8* null }] }, section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_P" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.50, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* null }] }, section "__DATA_CONST, __objc_const", align 8
+@OBJC_PROP_NAME_ATTR_.52 = private global [4 x i8] c"pp1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.53 = private global [3 x i8] c"Ti\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.54 = private global [4 x i8] c"pp2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@"\01l_OBJC_$_PROP_LIST_P" = private global { i32, i32, [2 x %struct._prop_t] } { i32 16, i32 2, [2 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.52, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_PROP_NAME_ATTR_.53, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.54, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_PROP_NAME_ATTR_.53, i32 0, i32 0) }] }, section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P" = private global [10 x i8*] [i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.33, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.7, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.7, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.33, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0)], section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_PROTOCOL_$_P" = weak hidden global %struct._protocol_t { i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.51, i32 0, i32 0), %struct._objc_protocol_list* null, %struct.__method_list_t* bitcast ({ i32, i32, [6 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P" to %struct.__method_list_t*), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_P" to %struct.__method_list_t*), %struct.__method_list_t* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_P" to %struct.__method_list_t*), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_P" to %struct.__method_list_t*), %struct._prop_list_t* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_P" to %struct._prop_list_t*), i32 96, i32 0, i8** getelementptr inbounds ([10 x i8*], [10 x i8*]* @"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P", i32 0, i32 0), i8* null, %struct._prop_list_t* null }, align 8
+@"\01l_OBJC_LABEL_PROTOCOL_$_P" = weak hidden global %struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P", section "__DATA_CONST, __objc_protolist, coalesced, no_dead_strip", align 8
+@"\01l_OBJC_CLASS_PROTOCOLS_$_PA" = private global { i64, [2 x %struct._protocol_t*] } { i64 1, [2 x %struct._protocol_t*] [%struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P", %struct._protocol_t* null] }, section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_METACLASS_RO_$_PA" = private global %struct._class_ro_t { i32 1, i32 40, i32 40, i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.40, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CLASS_METHODS_PA" to %struct.__method_list_t*), %struct._objc_protocol_list* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PA" to %struct._objc_protocol_list*), %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA_CONST, __objc_const", align 8
+@"OBJC_METACLASS_$_PA" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_A", %struct._class_t* @"OBJC_METACLASS_$_A", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_METACLASS_RO_$_PA" }, section "__DATA, __objc_data", align 8
+@"\01l_OBJC_$_INSTANCE_METHODS_PA" = private global { i32, i32, [2 x %struct._objc_method] } { i32 24, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.42, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%3*, i8*)* @"\01-[PA protoMethod1]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.43, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.33, i32 0, i32 0), i8* bitcast (void (%3*, i8*, i8*)* @"\01-[PA protoMethod2:]" to i8*) }] }, section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_$_PROP_LIST_PA" = private global { i32, i32, [2 x %struct._prop_t] } { i32 16, i32 2, [2 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.52, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.36, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.54, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.36, i32 0, i32 0) }] }, section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_CLASS_RO_$_PA" = private global %struct._class_ro_t { i32 0, i32 16, i32 16, i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.40, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_PA" to %struct.__method_list_t*), %struct._objc_protocol_list* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PA" to %struct._objc_protocol_list*), %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_PA" to %struct._prop_list_t*) }, section "__DATA_CONST, __objc_const", align 8
+@"OBJC_CLASS_$_PA" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_PA", %struct._class_t* @"OBJC_CLASS_$_A", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_CLASS_RO_$_PA" }, section "__DATA, __objc_data", align 8
+@"OBJC_METACLASS_$_E" = external global %struct._class_t
+@OBJC_CLASS_NAME_.55 = private global [3 x i8] c"PB\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.56 = private global [13 x i8] c"protoMethod7\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_CLASS_NAME_.57 = private global [3 x i8] c"P2\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P2" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.56, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* null }] }, section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P2" = private global [1 x i8*] [i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0)], section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_PROTOCOL_$_P2" = weak hidden global %struct._protocol_t { i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.57, i32 0, i32 0), %struct._objc_protocol_list* null, %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P2" to %struct.__method_list_t*), %struct.__method_list_t* null, %struct.__method_list_t* null, %struct.__method_list_t* null, %struct._prop_list_t* null, i32 96, i32 0, i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P2", i32 0, i32 0), i8* null, %struct._prop_list_t* null }, align 8
+@"\01l_OBJC_LABEL_PROTOCOL_$_P2" = weak hidden global %struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P2", section "__DATA_CONST, __objc_protolist, coalesced, no_dead_strip", align 8
+@"\01l_OBJC_CLASS_PROTOCOLS_$_PB" = private global { i64, [2 x %struct._protocol_t*] } { i64 1, [2 x %struct._protocol_t*] [%struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P2", %struct._protocol_t* null] }, section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_METACLASS_RO_$_PB" = private global %struct._class_ro_t { i32 1, i32 40, i32 40, i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.55, i32 0, i32 0), %struct.__method_list_t* null, %struct._objc_protocol_list* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PB" to %struct._objc_protocol_list*), %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA_CONST, __objc_const", align 8
+@"OBJC_METACLASS_$_PB" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_E", %struct._class_t* @"OBJC_METACLASS_$_E", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_METACLASS_RO_$_PB" }, section "__DATA, __objc_data", align 8
+@"OBJC_CLASS_$_E" = external global %struct._class_t
+@"\01l_OBJC_$_INSTANCE_METHODS_PB" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.56, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%4*, i8*)* @"\01-[PB protoMethod7]" to i8*) }] }, section "__DATA_CONST, __objc_const", align 8
+@"\01l_OBJC_CLASS_RO_$_PB" = private global %struct._class_ro_t { i32 0, i32 0, i32 0, i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.55, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_PB" to %struct.__method_list_t*), %struct._objc_protocol_list* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PB" to %struct._objc_protocol_list*), %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA_CONST, __objc_const", align 8
+@"OBJC_CLASS_$_PB" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_PB", %struct._class_t* @"OBJC_CLASS_$_E", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_CLASS_RO_$_PB" }, section "__DATA, __objc_data", align 8
+@"OBJC_LABEL_CLASS_$" = private global [4 x i8*] [i8* bitcast (%struct._class_t* @"OBJC_CLASS_$_A" to i8*), i8* bitcast (%struct._class_t* @"OBJC_CLASS_$_B" to i8*), i8* bitcast (%struct._class_t* @"OBJC_CLASS_$_PA" to i8*), i8* bitcast (%struct._class_t* @"OBJC_CLASS_$_PB" to i8*)], section "__DATA_CONST, __objc_classlist, regular, no_dead_strip", align 8
+@"OBJC_LABEL_CATEGORY_$" = private global [2 x i8*] [i8* bitcast (%struct._category_t* @"\01l_OBJC_$_CATEGORY_A_$_C" to i8*), i8* bitcast (%struct._category_t* @"\01l_OBJC_$_CATEGORY_A_$_C1" to i8*)], section "__DATA_CONST, __objc_catlist, regular, no_dead_strip", align 8
[e-mail] = appending global [93 x i8*] [i8* bitcast (%struct._category_t* @"\01l_OBJC_$_CATEGORY_A_$_C" to i8*), i8* bitcast (%struct._category_t* @"\01l_OBJC_$_CATEGORY_A_$_C1" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_CLASS_METHODS_A_$_C" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C1" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_CLASS_METHODS_A" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CLASS_METHODS_PA" to i8*), i8* bitcast ({ i32, i32, [9 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_A" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_B" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_PA" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_PB" to i8*), i8* bitcast ({ i32, i32, [4 x %struct._ivar_t] }* @"\01l_OBJC_$_INSTANCE_VARIABLES_A" to i8*), i8* bitcast ({ i32, i32, [4 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A_$_C" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_P" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_PA" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_P" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_P" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_P" to i8*), i8* bitcast ({ i32, i32, [6 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P2" to i8*), i8* bitcast ([10 x i8*]* @"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P" to i8*), i8* bitcast ([1 x i8*]* @"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P2" to i8*), i8* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PA" to i8*), i8* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PB" to i8*), i8* bitcast (%struct._protocol_t** @"\01l_OBJC_LABEL_PROTOCOL_$_P" to i8*), i8* bitcast (%struct._protocol_t** @"\01l_OBJC_LABEL_PROTOCOL_$_P2" to i8*), i8* bitcast (%struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P" to i8*), i8* bitcast (%struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P2" to i8*), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.26, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.30, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.38, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.40, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.51, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.55, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.57, i32 0, i32 0), i8* bitcast ([2 x i8*]* @"OBJC_LABEL_CATEGORY_$" to i8*), i8* bitcast ([4 x i8*]* @"OBJC_LABEL_CLASS_$" to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.1, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.10, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_NAME_.11, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.12, i32 0, i32 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @OBJC_METH_VAR_NAME_.13, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.14, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.16, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.17, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.18, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.27, i32 0, i32 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @OBJC_METH_VAR_NAME_.28, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.3, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.31, i32 0, i32 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @OBJC_METH_VAR_NAME_.32, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.34, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.39, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.4, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.41, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.42, i32 0, i32 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.43, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.44, i32 0, i32 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.45, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.46, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.47, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.48, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.49, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.50, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.56, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.6, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_NAME_.8, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.9, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_METH_VAR_TYPE_.15, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.33, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.7, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_PROP_NAME_ATTR_.19, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.20, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_PROP_NAME_ATTR_.21, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.22, i32 0, i32 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @OBJC_PROP_NAME_ATTR_.23, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.24, i32 0, i32 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @OBJC_PROP_NAME_ATTR_.25, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.35, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.36, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.37, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.52, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_PROP_NAME_ATTR_.53, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.54, i32 0, i32 0), i8* bitcast (i8** @OBJC_SELECTOR_REFERENCES_ to i8*), i8* bitcast (i8** @OBJC_SELECTOR_REFERENCES_.2 to i8*), i8* bitcast (i8** @OBJC_SELECTOR_REFERENCES_.29 to i8*)], section "llvm.metadata"
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[A meth1]"(%0* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: optsize ssp uwtable
+define internal void @"\01-[A meth2:]"(%0*, i8* nocapture readnone, i32) #1 {
+  %4 = load i8*, i8** @OBJC_SELECTOR_REFERENCES_, align 8, !invariant.load !7
+  %5 = bitcast %0* %0 to i8*
+  tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*)*)(i8* %5, i8* %4) #5
+  %6 = load i8*, i8** @OBJC_SELECTOR_REFERENCES_.2, align 8, !invariant.load !7
+  %7 = tail call i32 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i32 (i8*, i8*)*)(i8* %5, i8* %6) #5
+  ret void
+}
+
+; Function Attrs: nonlazybind
+declare i8* @objc_msgSend(i8*, i8*, ...) #2
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01+[A meth3]"(i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01+[A meth4:]"(i8* nocapture, i8* nocapture, i32) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readonly ssp uwtable
+define internal i32 @"\01-[A prop1]"(%0* nocapture readonly, i8* nocapture readnone) #3 {
+  %3 = load i64, i64* @"OBJC_IVAR_$_A._prop1", align 8, !invariant.load !7
+  %4 = bitcast %0* %0 to i8*
+  %5 = getelementptr inbounds i8, i8* %4, i64 %3
+  %6 = bitcast i8* %5 to i32*
+  %7 = load atomic i32, i32* %6 unordered, align 4
+  ret i32 %7
+}
+
+; Function Attrs: norecurse nounwind optsize ssp uwtable
+define internal void @"\01-[A setProp1:]"(%0* nocapture, i8* nocapture readnone, i32) #4 {
+  %4 = load i64, i64* @"OBJC_IVAR_$_A._prop1", align 8, !invariant.load !7
+  %5 = bitcast %0* %0 to i8*
+  %6 = getelementptr inbounds i8, i8* %5, i64 %4
+  %7 = bitcast i8* %6 to i32*
+  store atomic i32 %2, i32* %7 unordered, align 4
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readonly ssp uwtable
+define internal i32 @"\01-[A prop2]"(%0* nocapture readonly, i8* nocapture readnone) #3 {
+  %3 = load i64, i64* @"OBJC_IVAR_$_A._prop2", align 8, !invariant.load !7
+  %4 = bitcast %0* %0 to i8*
+  %5 = getelementptr inbounds i8, i8* %4, i64 %3
+  %6 = bitcast i8* %5 to i32*
+  %7 = load atomic i32, i32* %6 unordered, align 4
+  ret i32 %7
+}
+
+; Function Attrs: norecurse nounwind optsize readonly ssp uwtable
+define internal i32 @"\01-[A isProp3]"(%0* nocapture readonly, i8* nocapture readnone) #3 {
+  %3 = load i64, i64* @"OBJC_IVAR_$_A._prop3", align 8, !invariant.load !7
+  %4 = bitcast %0* %0 to i8*
+  %5 = getelementptr inbounds i8, i8* %4, i64 %3
+  %6 = bitcast i8* %5 to i32*
+  %7 = load atomic i32, i32* %6 unordered, align 4
+  ret i32 %7
+}
+
+; Function Attrs: norecurse nounwind optsize ssp uwtable
+define internal void @"\01-[A setProp3:]"(%0* nocapture, i8* nocapture readnone, i32) #4 {
+  %4 = load i64, i64* @"OBJC_IVAR_$_A._prop3", align 8, !invariant.load !7
+  %5 = bitcast %0* %0 to i8*
+  %6 = getelementptr inbounds i8, i8* %5, i64 %4
+  %7 = bitcast i8* %6 to i32*
+  store atomic i32 %2, i32* %7 unordered, align 4
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readonly ssp uwtable
+define internal i32 @"\01-[A prop4]"(%0* nocapture readonly, i8* nocapture readnone) #3 {
+  %3 = load i64, i64* @"OBJC_IVAR_$_A._prop4", align 8, !invariant.load !7
+  %4 = bitcast %0* %0 to i8*
+  %5 = getelementptr inbounds i8, i8* %4, i64 %3
+  %6 = bitcast i8* %5 to i32*
+  %7 = load atomic i32, i32* %6 unordered, align 4
+  ret i32 %7
+}
+
+; Function Attrs: norecurse nounwind optsize ssp uwtable
+define internal void @"\01-[A prop4To:]"(%0* nocapture, i8* nocapture readnone, i32) #4 {
+  %4 = load i64, i64* @"OBJC_IVAR_$_A._prop4", align 8, !invariant.load !7
+  %5 = bitcast %0* %0 to i8*
+  %6 = getelementptr inbounds i8, i8* %5, i64 %4
+  %7 = bitcast i8* %6 to i32*
+  store atomic i32 %2, i32* %7 unordered, align 4
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[B method]"(%1* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[A(C) catMethod1]"(%0* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01+[A(C) catMethod2]"(i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: optsize ssp uwtable
+define internal void @"\01-[A(C) catMethod3:]"(%0* nocapture readnone, i8* nocapture readnone, %2*) #1 {
+  %4 = load i8*, i8** @OBJC_SELECTOR_REFERENCES_.29, align 8, !invariant.load !7
+  %5 = bitcast %2* %2 to i8*
+  tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*)*)(i8* %5, i8* %4) #5
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[A(C1) catMethod3]"(%0* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[PA protoMethod1]"(%3* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[PA protoMethod2:]"(%3* nocapture, i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01+[PA protoMethod3]"(i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[PB protoMethod7]"(%4* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define i32 @main() #0 {
+  ret i32 0
+}
+
+attributes #0 = { norecurse nounwind optsize readnone ssp uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+fxsr,+mmx,+sse,+sse2,+sse3,+sse4.1,+ssse3" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { optsize ssp uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+fxsr,+mmx,+sse,+sse2,+sse3,+sse4.1,+ssse3" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #2 = { nonlazybind }
+attributes #3 = { norecurse nounwind optsize readonly ssp uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+fxsr,+mmx,+sse,+sse2,+sse3,+sse4.1,+ssse3" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #4 = { norecurse nounwind optsize ssp uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+fxsr,+mmx,+sse,+sse2,+sse3,+sse4.1,+ssse3" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #5 = { optsize }
+
+!llvm.module.flags = !{!0, !1, !2, !3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = !{i32 1, !"Objective-C Version", i32 2}
+!1 = !{i32 1, !"Objective-C Image Info Version", i32 0}
+!2 = !{i32 1, !"Objective-C Image Info Section", !"__DATA, __objc_imageinfo, regular, no_dead_strip"}
+!3 = !{i32 4, !"Objective-C Garbage Collection", i32 0}
+!4 = !{i32 1, !"Objective-C Class Properties", i32 64}
+!5 = !{i32 1, !"PIC Level", i32 2}
+!6 = !{!"Apple LLVM version 8.0.0 (clang-800.0.35)"}
+!7 = !{}

llvm/test/Object/ObjCMetadata/objc-metadata-arm64.ll

+; RUN: llvm-objc-metadata %s | FileCheck %s
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: llvm-objc-metadata %t.o | FileCheck %s
+; CHECK: Objective-C Classes:
+; CHECK: # A :
+; CHECK:   instance method: meth1
+; CHECK:   instance method: meth2:
+; CHECK:   instance method: prop1
+; CHECK:   instance method: setProp1:
+; CHECK:   instance method: prop2
+; CHECK:   instance method: isProp3
+; CHECK:   instance method: setProp3:
+; CHECK:   instance method: prop4
+; CHECK:   instance method: prop4To:
+; CHECK:   class method: meth3
+; CHECK:   class method: meth4:
+; CHECK:   property: prop1
+; CHECK:   property: prop2
+; CHECK:   property: prop3
+; CHECK:   property: prop4
+; CHECK:   class property: prop5
+; CHECK: # B : A
+; CHECK:   instance method: method
+; CHECK: # PA : A
+; CHECK:   instance method: protoMethod1
+; CHECK:   instance method: protoMethod2:
+; CHECK:   class method: protoMethod3
+; CHECK:   property: pp1
+; CHECK:   property: pp2
+; CHECK: # PB : E
+; CHECK:   instance method: protoMethod7
+; CHECK: Objective-C Protocols:
+; CHECK: # P
+; CHECK:   instance method: protoMethod1
+; CHECK:   instance method: protoMethod2:
+; CHECK:   instance method: pp1
+; CHECK:   instance method: setPp1:
+; CHECK:   instance method: pp2
+; CHECK:   instance method: setPp2:
+; CHECK:   optional instance method: protoMethod4
+; CHECK:   optional instance method: protoMethod5:
+; CHECK:   class method: protoMethod3
+; CHECK:   optional class method: protoMethod6
+; CHECK:   property: pp1
+; CHECK:   property: pp2
+; CHECK: # P2
+; CHECK:   instance method: protoMethod7
+; CHECK: Objective-C Categories:
+; CHECK: # A(C)
+; CHECK:   instance method: catMethod1
+; CHECK:   instance method: catMethod3:
+; CHECK:   class method: catMethod2
+; CHECK:   property: cp1
+; CHECK:   property: cp2
+; CHECK: # A(C1)
+; CHECK:   instance method: catMethod3
+
+; ModuleID = 'objc-metadata.m'
+source_filename = "objc-metadata.m"
+target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
+target triple = "arm64-apple-ios13.0.0"
+
+%0 = type opaque
+%1 = type opaque
+%2 = type opaque
+%3 = type opaque
+%4 = type opaque
+%struct._objc_cache = type opaque
+%struct._class_t = type { %struct._class_t*, %struct._class_t*, %struct._objc_cache*, i8* (i8*, i8*)**, %struct._class_ro_t* }
+%struct._class_ro_t = type { i32, i32, i32, i8*, i8*, %struct.__method_list_t*, %struct._objc_protocol_list*, %struct._ivar_list_t*, i8*, %struct._prop_list_t* }
+%struct.__method_list_t = type { i32, i32, [0 x %struct._objc_method] }
+%struct._objc_method = type { i8*, i8*, i8* }
+%struct._objc_protocol_list = type { i64, [0 x %struct._protocol_t*] }
+%struct._protocol_t = type { i8*, i8*, %struct._objc_protocol_list*, %struct.__method_list_t*, %struct.__method_list_t*, %struct.__method_list_t*, %struct.__method_list_t*, %struct._prop_list_t*, i32, i32, i8**, i8*, %struct._prop_list_t* }
+%struct._ivar_list_t = type { i32, i32, [0 x %struct._ivar_t] }
+%struct._ivar_t = type { i32*, i8*, i8*, i32, i32 }
+%struct._prop_list_t = type { i32, i32, [0 x %struct._prop_t] }
+%struct._prop_t = type { i8*, i8* }
+%struct._category_t = type { i8*, %struct._class_t*, %struct.__method_list_t*, %struct.__method_list_t*, %struct._objc_protocol_list*, %struct._prop_list_t*, %struct._prop_list_t*, i32 }
+
+@OBJC_METH_VAR_NAME_ = private unnamed_addr constant [6 x i8] c"meth1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_SELECTOR_REFERENCES_ = private externally_initialized global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_, i64 0, i64 0), section "__DATA,__objc_selrefs,literal_pointers,no_dead_strip", align 8
+@OBJC_METH_VAR_NAME_.1 = private unnamed_addr constant [6 x i8] c"prop1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_SELECTOR_REFERENCES_.2 = private externally_initialized global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.1, i64 0, i64 0), section "__DATA,__objc_selrefs,literal_pointers,no_dead_strip", align 8
+@"OBJC_IVAR_$_A._prop1" = hidden global i32 0, section "__DATA, __objc_ivar", align 4
+@"OBJC_IVAR_$_A._prop2" = hidden global i32 4, section "__DATA, __objc_ivar", align 4
+@"OBJC_IVAR_$_A._prop3" = hidden global i32 8, section "__DATA, __objc_ivar", align 4
+@"OBJC_IVAR_$_A._prop4" = hidden global i32 12, section "__DATA, __objc_ivar", align 4
+@_objc_empty_cache = external global %struct._objc_cache
+@"OBJC_CLASS_$_A" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_A", %struct._class_t* null, %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_CLASS_RO_$_A" }, section "__DATA, __objc_data", align 8
+@"OBJC_METACLASS_$_A" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_A", %struct._class_t* @"OBJC_CLASS_$_A", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_METACLASS_RO_$_A" }, section "__DATA, __objc_data", align 8
+@OBJC_CLASS_NAME_ = private unnamed_addr constant [2 x i8] c"A\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.3 = private unnamed_addr constant [6 x i8] c"meth3\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_ = private unnamed_addr constant [8 x i8] c"v16@0:8\00", section "__TEXT,__objc_methtype,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.4 = private unnamed_addr constant [7 x i8] c"meth4:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_.5 = private unnamed_addr constant [11 x i8] c"v20@0:8i16\00", section "__TEXT,__objc_methtype,cstring_literals", align 1
+@"\01l_OBJC_$_CLASS_METHODS_A" = private global { i32, i32, [2 x %struct._objc_method] } { i32 24, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.3, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (i8*, i8*)* @"\01+[A meth3]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.4, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* bitcast (void (i8*, i8*, i32)* @"\01+[A meth4:]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@OBJC_PROP_NAME_ATTR_ = private unnamed_addr constant [6 x i8] c"prop5\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.6 = private unnamed_addr constant [5 x i8] c"Ti,D\00", section "__TEXT,__cstring,cstring_literals", align 1
+@"\01l_OBJC_$_CLASS_PROP_LIST_A" = private global { i32, i32, [1 x %struct._prop_t] } { i32 16, i32 1, [1 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.6, i32 0, i32 0) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_METACLASS_RO_$_A" = private global %struct._class_ro_t { i32 3, i32 40, i32 40, i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_CLASS_METHODS_A" to %struct.__method_list_t*), %struct._objc_protocol_list* null, %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* bitcast ({ i32, i32, [1 x %struct._prop_t] }* @"\01l_OBJC_$_CLASS_PROP_LIST_A" to %struct._prop_list_t*) }, section "__DATA, __objc_const", align 8
+@OBJC_METH_VAR_NAME_.7 = private unnamed_addr constant [7 x i8] c"meth2:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_.8 = private unnamed_addr constant [8 x i8] c"i16@0:8\00", section "__TEXT,__objc_methtype,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.9 = private unnamed_addr constant [10 x i8] c"setProp1:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.10 = private unnamed_addr constant [6 x i8] c"prop2\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.11 = private unnamed_addr constant [8 x i8] c"isProp3\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.12 = private unnamed_addr constant [10 x i8] c"setProp3:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.13 = private unnamed_addr constant [6 x i8] c"prop4\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.14 = private unnamed_addr constant [9 x i8] c"prop4To:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_INSTANCE_METHODS_A" = private global { i32, i32, [9 x %struct._objc_method] } { i32 24, i32 9, [9 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%0*, i8*)* @"\01-[A meth1]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.7, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* bitcast (void (%0*, i8*, i32)* @"\01-[A meth2:]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.1, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* bitcast (i32 (%0*, i8*)* @"\01-[A prop1]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_NAME_.9, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* bitcast (void (%0*, i8*, i32)* @"\01-[A setProp1:]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.10, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* bitcast (i32 (%0*, i8*)* @"\01-[A prop2]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.11, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* bitcast (i32 (%0*, i8*)* @"\01-[A isProp3]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_NAME_.12, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* bitcast (void (%0*, i8*, i32)* @"\01-[A setProp3:]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.13, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* bitcast (i32 (%0*, i8*)* @"\01-[A prop4]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @OBJC_METH_VAR_NAME_.14, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* bitcast (void (%0*, i8*, i32)* @"\01-[A prop4To:]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@OBJC_METH_VAR_NAME_.15 = private unnamed_addr constant [7 x i8] c"_prop1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_.16 = private unnamed_addr constant [2 x i8] c"i\00", section "__TEXT,__objc_methtype,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.17 = private unnamed_addr constant [7 x i8] c"_prop2\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.18 = private unnamed_addr constant [7 x i8] c"_prop3\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.19 = private unnamed_addr constant [7 x i8] c"_prop4\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_INSTANCE_VARIABLES_A" = private global { i32, i32, [4 x %struct._ivar_t] } { i32 32, i32 4, [4 x %struct._ivar_t] [%struct._ivar_t { i32* @"OBJC_IVAR_$_A._prop1", i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.15, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_METH_VAR_TYPE_.16, i32 0, i32 0), i32 2, i32 4 }, %struct._ivar_t { i32* @"OBJC_IVAR_$_A._prop2", i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.17, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_METH_VAR_TYPE_.16, i32 0, i32 0), i32 2, i32 4 }, %struct._ivar_t { i32* @"OBJC_IVAR_$_A._prop3", i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.18, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_METH_VAR_TYPE_.16, i32 0, i32 0), i32 2, i32 4 }, %struct._ivar_t { i32* @"OBJC_IVAR_$_A._prop4", i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.19, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_METH_VAR_TYPE_.16, i32 0, i32 0), i32 2, i32 4 }] }, section "__DATA, __objc_const", align 8
+@OBJC_PROP_NAME_ATTR_.20 = private unnamed_addr constant [6 x i8] c"prop1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.21 = private unnamed_addr constant [11 x i8] c"Ti,V_prop1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.22 = private unnamed_addr constant [6 x i8] c"prop2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.23 = private unnamed_addr constant [13 x i8] c"Ti,R,V_prop2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.24 = private unnamed_addr constant [6 x i8] c"prop3\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.25 = private unnamed_addr constant [20 x i8] c"Ti,GisProp3,V_prop3\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.26 = private unnamed_addr constant [6 x i8] c"prop4\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.27 = private unnamed_addr constant [21 x i8] c"Ti,Sprop4To:,V_prop4\00", section "__TEXT,__cstring,cstring_literals", align 1
+@"\01l_OBJC_$_PROP_LIST_A" = private global { i32, i32, [4 x %struct._prop_t] } { i32 16, i32 4, [4 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.20, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_PROP_NAME_ATTR_.21, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.22, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_PROP_NAME_ATTR_.23, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.24, i32 0, i32 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @OBJC_PROP_NAME_ATTR_.25, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.26, i32 0, i32 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @OBJC_PROP_NAME_ATTR_.27, i32 0, i32 0) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_CLASS_RO_$_A" = private global %struct._class_ro_t { i32 2, i32 0, i32 16, i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [9 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_A" to %struct.__method_list_t*), %struct._objc_protocol_list* null, %struct._ivar_list_t* bitcast ({ i32, i32, [4 x %struct._ivar_t] }* @"\01l_OBJC_$_INSTANCE_VARIABLES_A" to %struct._ivar_list_t*), i8* null, %struct._prop_list_t* bitcast ({ i32, i32, [4 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A" to %struct._prop_list_t*) }, section "__DATA, __objc_const", align 8
+@OBJC_CLASS_NAME_.28 = private unnamed_addr constant [2 x i8] c"B\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@"\01l_OBJC_METACLASS_RO_$_B" = private global %struct._class_ro_t { i32 1, i32 40, i32 40, i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.28, i32 0, i32 0), %struct.__method_list_t* null, %struct._objc_protocol_list* null, %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA, __objc_const", align 8
+@"OBJC_METACLASS_$_B" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_A", %struct._class_t* @"OBJC_METACLASS_$_A", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_METACLASS_RO_$_B" }, section "__DATA, __objc_data", align 8
+@OBJC_METH_VAR_NAME_.29 = private unnamed_addr constant [7 x i8] c"method\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_INSTANCE_METHODS_B" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.29, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%1*, i8*)* @"\01-[B method]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_CLASS_RO_$_B" = private global %struct._class_ro_t { i32 0, i32 16, i32 16, i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.28, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_B" to %struct.__method_list_t*), %struct._objc_protocol_list* null, %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA, __objc_const", align 8
+@"OBJC_CLASS_$_B" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_B", %struct._class_t* @"OBJC_CLASS_$_A", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_CLASS_RO_$_B" }, section "__DATA, __objc_data", align 8
+@OBJC_METH_VAR_NAME_.30 = private unnamed_addr constant [9 x i8] c"external\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_SELECTOR_REFERENCES_.31 = private externally_initialized global i8* getelementptr inbounds ([9 x i8], [9 x i8]* @OBJC_METH_VAR_NAME_.30, i64 0, i64 0), section "__DATA,__objc_selrefs,literal_pointers,no_dead_strip", align 8
+@OBJC_CLASS_NAME_.32 = private unnamed_addr constant [2 x i8] c"C\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.33 = private unnamed_addr constant [11 x i8] c"catMethod1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.34 = private unnamed_addr constant [12 x i8] c"catMethod3:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_.35 = private unnamed_addr constant [11 x i8] c"v24@0:8@16\00", section "__TEXT,__objc_methtype,cstring_literals", align 1
+@"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C" = private global { i32, i32, [2 x %struct._objc_method] } { i32 24, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.33, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%0*, i8*)* @"\01-[A(C) catMethod1]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([12 x i8], [12 x i8]* @OBJC_METH_VAR_NAME_.34, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.35, i32 0, i32 0), i8* bitcast (void (%0*, i8*, %2*)* @"\01-[A(C) catMethod3:]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@OBJC_METH_VAR_NAME_.36 = private unnamed_addr constant [11 x i8] c"catMethod2\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_CATEGORY_CLASS_METHODS_A_$_C" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.36, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (i8*, i8*)* @"\01+[A(C) catMethod2]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@OBJC_PROP_NAME_ATTR_.37 = private unnamed_addr constant [4 x i8] c"cp1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.38 = private unnamed_addr constant [4 x i8] c"cp2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@"\01l_OBJC_$_PROP_LIST_A_$_C" = private global { i32, i32, [2 x %struct._prop_t] } { i32 16, i32 2, [2 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.37, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.6, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.38, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.6, i32 0, i32 0) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_$_CATEGORY_A_$_C" = private global %struct._category_t { i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.32, i32 0, i32 0), %struct._class_t* @"OBJC_CLASS_$_A", %struct.__method_list_t* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C" to %struct.__method_list_t*), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_CLASS_METHODS_A_$_C" to %struct.__method_list_t*), %struct._objc_protocol_list* null, %struct._prop_list_t* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A_$_C" to %struct._prop_list_t*), %struct._prop_list_t* null, i32 64 }, section "__DATA, __objc_const", align 8
+@OBJC_CLASS_NAME_.39 = private unnamed_addr constant [3 x i8] c"C1\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.40 = private unnamed_addr constant [11 x i8] c"catMethod3\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C1" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.40, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%0*, i8*)* @"\01-[A(C1) catMethod3]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_$_CATEGORY_A_$_C1" = private global %struct._category_t { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.39, i32 0, i32 0), %struct._class_t* @"OBJC_CLASS_$_A", %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C1" to %struct.__method_list_t*), %struct.__method_list_t* null, %struct._objc_protocol_list* null, %struct._prop_list_t* null, %struct._prop_list_t* null, i32 64 }, section "__DATA, __objc_const", align 8
+@OBJC_CLASS_NAME_.41 = private unnamed_addr constant [3 x i8] c"PA\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.42 = private unnamed_addr constant [13 x i8] c"protoMethod3\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_CLASS_METHODS_PA" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.42, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (i8*, i8*)* @"\01+[PA protoMethod3]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@OBJC_CLASS_NAME_.43 = private unnamed_addr constant [2 x i8] c"P\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.44 = private unnamed_addr constant [13 x i8] c"protoMethod1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.45 = private unnamed_addr constant [14 x i8] c"protoMethod2:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.46 = private unnamed_addr constant [4 x i8] c"pp1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.47 = private unnamed_addr constant [8 x i8] c"setPp1:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.48 = private unnamed_addr constant [4 x i8] c"pp2\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.49 = private unnamed_addr constant [8 x i8] c"setPp2:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P" = private global { i32, i32, [6 x %struct._objc_method] } { i32 24, i32 6, [6 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.44, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.45, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.35, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.46, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.47, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.48, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.49, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* null }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_P" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.42, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* null }] }, section "__DATA, __objc_const", align 8
+@OBJC_METH_VAR_NAME_.50 = private unnamed_addr constant [13 x i8] c"protoMethod4\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.51 = private unnamed_addr constant [14 x i8] c"protoMethod5:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_P" = private global { i32, i32, [2 x %struct._objc_method] } { i32 24, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.50, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.51, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.35, i32 0, i32 0), i8* null }] }, section "__DATA, __objc_const", align 8
+@OBJC_METH_VAR_NAME_.52 = private unnamed_addr constant [13 x i8] c"protoMethod6\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_P" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.52, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* null }] }, section "__DATA, __objc_const", align 8
+@OBJC_PROP_NAME_ATTR_.53 = private unnamed_addr constant [4 x i8] c"pp1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.54 = private unnamed_addr constant [3 x i8] c"Ti\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.55 = private unnamed_addr constant [4 x i8] c"pp2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@"\01l_OBJC_$_PROP_LIST_P" = private global { i32, i32, [2 x %struct._prop_t] } { i32 16, i32 2, [2 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.53, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_PROP_NAME_ATTR_.54, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.55, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_PROP_NAME_ATTR_.54, i32 0, i32 0) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P" = private global [10 x i8*] [i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.35, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.35, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0)], section "__DATA, __objc_const", align 8
+@"\01l_OBJC_PROTOCOL_$_P" = weak hidden global %struct._protocol_t { i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.43, i32 0, i32 0), %struct._objc_protocol_list* null, %struct.__method_list_t* bitcast ({ i32, i32, [6 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P" to %struct.__method_list_t*), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_P" to %struct.__method_list_t*), %struct.__method_list_t* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_P" to %struct.__method_list_t*), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_P" to %struct.__method_list_t*), %struct._prop_list_t* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_P" to %struct._prop_list_t*), i32 96, i32 0, i8** getelementptr inbounds ([10 x i8*], [10 x i8*]* @"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P", i32 0, i32 0), i8* null, %struct._prop_list_t* null }, align 8
+@"\01l_OBJC_LABEL_PROTOCOL_$_P" = weak hidden global %struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P", section "__DATA,__objc_protolist,coalesced,no_dead_strip", align 8
+@"\01l_OBJC_CLASS_PROTOCOLS_$_PA" = private global { i64, [2 x %struct._protocol_t*] } { i64 1, [2 x %struct._protocol_t*] [%struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P", %struct._protocol_t* null] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_METACLASS_RO_$_PA" = private global %struct._class_ro_t { i32 1, i32 40, i32 40, i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.41, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CLASS_METHODS_PA" to %struct.__method_list_t*), %struct._objc_protocol_list* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PA" to %struct._objc_protocol_list*), %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA, __objc_const", align 8
+@"OBJC_METACLASS_$_PA" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_A", %struct._class_t* @"OBJC_METACLASS_$_A", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_METACLASS_RO_$_PA" }, section "__DATA, __objc_data", align 8
+@"\01l_OBJC_$_INSTANCE_METHODS_PA" = private global { i32, i32, [2 x %struct._objc_method] } { i32 24, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.44, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%3*, i8*)* @"\01-[PA protoMethod1]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.45, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.35, i32 0, i32 0), i8* bitcast (void (%3*, i8*, i8*)* @"\01-[PA protoMethod2:]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_$_PROP_LIST_PA" = private global { i32, i32, [2 x %struct._prop_t] } { i32 16, i32 2, [2 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.53, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.6, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.55, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.6, i32 0, i32 0) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_CLASS_RO_$_PA" = private global %struct._class_ro_t { i32 0, i32 16, i32 16, i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.41, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_PA" to %struct.__method_list_t*), %struct._objc_protocol_list* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PA" to %struct._objc_protocol_list*), %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_PA" to %struct._prop_list_t*) }, section "__DATA, __objc_const", align 8
+@"OBJC_CLASS_$_PA" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_PA", %struct._class_t* @"OBJC_CLASS_$_A", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_CLASS_RO_$_PA" }, section "__DATA, __objc_data", align 8
+@"OBJC_METACLASS_$_E" = external global %struct._class_t
+@OBJC_CLASS_NAME_.56 = private unnamed_addr constant [3 x i8] c"PB\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_CLASS_NAME_.57 = private unnamed_addr constant [3 x i8] c"P2\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.58 = private unnamed_addr constant [13 x i8] c"protoMethod7\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P2" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.58, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* null }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P2" = private global [1 x i8*] [i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0)], section "__DATA, __objc_const", align 8
+@"\01l_OBJC_PROTOCOL_$_P2" = weak hidden global %struct._protocol_t { i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.57, i32 0, i32 0), %struct._objc_protocol_list* null, %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P2" to %struct.__method_list_t*), %struct.__method_list_t* null, %struct.__method_list_t* null, %struct.__method_list_t* null, %struct._prop_list_t* null, i32 96, i32 0, i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P2", i32 0, i32 0), i8* null, %struct._prop_list_t* null }, align 8
+@"\01l_OBJC_LABEL_PROTOCOL_$_P2" = weak hidden global %struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P2", section "__DATA,__objc_protolist,coalesced,no_dead_strip", align 8
+@"\01l_OBJC_CLASS_PROTOCOLS_$_PB" = private global { i64, [2 x %struct._protocol_t*] } { i64 1, [2 x %struct._protocol_t*] [%struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P2", %struct._protocol_t* null] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_METACLASS_RO_$_PB" = private global %struct._class_ro_t { i32 1, i32 40, i32 40, i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.56, i32 0, i32 0), %struct.__method_list_t* null, %struct._objc_protocol_list* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PB" to %struct._objc_protocol_list*), %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA, __objc_const", align 8
+@"OBJC_METACLASS_$_PB" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_E", %struct._class_t* @"OBJC_METACLASS_$_E", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_METACLASS_RO_$_PB" }, section "__DATA, __objc_data", align 8
+@"OBJC_CLASS_$_E" = external global %struct._class_t
+@"\01l_OBJC_$_INSTANCE_METHODS_PB" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.58, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%4*, i8*)* @"\01-[PB protoMethod7]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_CLASS_RO_$_PB" = private global %struct._class_ro_t { i32 0, i32 0, i32 0, i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.56, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_PB" to %struct.__method_list_t*), %struct._objc_protocol_list* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PB" to %struct._objc_protocol_list*), %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA, __objc_const", align 8
+@"OBJC_CLASS_$_PB" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_PB", %struct._class_t* @"OBJC_CLASS_$_E", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_CLASS_RO_$_PB" }, section "__DATA, __objc_data", align 8
+@"OBJC_LABEL_CLASS_$" = private global [4 x i8*] [i8* bitcast (%struct._class_t* @"OBJC_CLASS_$_A" to i8*), i8* bitcast (%struct._class_t* @"OBJC_CLASS_$_B" to i8*), i8* bitcast (%struct._class_t* @"OBJC_CLASS_$_PA" to i8*), i8* bitcast (%struct._class_t* @"OBJC_CLASS_$_PB" to i8*)], section "__DATA,__objc_classlist,regular,no_dead_strip", align 8
+@"OBJC_LABEL_CATEGORY_$" = private global [2 x i8*] [i8* bitcast (%struct._category_t* @"\01l_OBJC_$_CATEGORY_A_$_C" to i8*), i8* bitcast (%struct._category_t* @"\01l_OBJC_$_CATEGORY_A_$_C1" to i8*)], section "__DATA,__objc_catlist,regular,no_dead_strip", align 8
[e-mail] = appending global [95 x i8*] [i8* bitcast (%struct._category_t* @"\01l_OBJC_$_CATEGORY_A_$_C" to i8*), i8* bitcast (%struct._category_t* @"\01l_OBJC_$_CATEGORY_A_$_C1" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_CLASS_METHODS_A_$_C" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C1" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_CLASS_METHODS_A" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CLASS_METHODS_PA" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._prop_t] }* @"\01l_OBJC_$_CLASS_PROP_LIST_A" to i8*), i8* bitcast ({ i32, i32, [9 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_A" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_B" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_PA" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_PB" to i8*), i8* bitcast ({ i32, i32, [4 x %struct._ivar_t] }* @"\01l_OBJC_$_INSTANCE_VARIABLES_A" to i8*), i8* bitcast ({ i32, i32, [4 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A_$_C" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_P" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_PA" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_P" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_P" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_P" to i8*), i8* bitcast ({ i32, i32, [6 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P2" to i8*), i8* bitcast ([10 x i8*]* @"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P" to i8*), i8* bitcast ([1 x i8*]* @"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P2" to i8*), i8* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PA" to i8*), i8* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PB" to i8*), i8* bitcast (%struct._protocol_t** @"\01l_OBJC_LABEL_PROTOCOL_$_P" to i8*), i8* bitcast (%struct._protocol_t** @"\01l_OBJC_LABEL_PROTOCOL_$_P2" to i8*), i8* bitcast (%struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P" to i8*), i8* bitcast (%struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P2" to i8*), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.28, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.32, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.39, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.41, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.43, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.56, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.57, i32 0, i32 0), i8* bitcast ([2 x i8*]* @"OBJC_LABEL_CATEGORY_$" to i8*), i8* bitcast ([4 x i8*]* @"OBJC_LABEL_CLASS_$" to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.1, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.10, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.11, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_NAME_.12, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.13, i32 0, i32 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @OBJC_METH_VAR_NAME_.14, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.15, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.17, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.18, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.19, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.29, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.3, i32 0, i32 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @OBJC_METH_VAR_NAME_.30, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.33, i32 0, i32 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @OBJC_METH_VAR_NAME_.34, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.36, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.4, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.40, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.42, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.44, i32 0, i32 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.45, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.46, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.47, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.48, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.49, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.50, i32 0, i32 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.51, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.52, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.58, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.7, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_NAME_.9, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_METH_VAR_TYPE_.16, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.35, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.20, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_PROP_NAME_ATTR_.21, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.22, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_PROP_NAME_ATTR_.23, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.24, i32 0, i32 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @OBJC_PROP_NAME_ATTR_.25, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.26, i32 0, i32 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @OBJC_PROP_NAME_ATTR_.27, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.37, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.38, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.53, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_PROP_NAME_ATTR_.54, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.55, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.6, i32 0, i32 0), i8* bitcast (i8** @OBJC_SELECTOR_REFERENCES_ to i8*), i8* bitcast (i8** @OBJC_SELECTOR_REFERENCES_.2 to i8*), i8* bitcast (i8** @OBJC_SELECTOR_REFERENCES_.31 to i8*)], section "llvm.metadata"
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[A meth1]"(%0* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: optsize ssp uwtable
+define internal void @"\01-[A meth2:]"(%0*, i8* nocapture readnone, i32) #1 {
+  %4 = load i8*, i8** @OBJC_SELECTOR_REFERENCES_, align 8, !invariant.load !8
+  %5 = bitcast %0* %0 to i8*
+  tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*)*)(i8* %5, i8* %4) #5
+  %6 = load i8*, i8** @OBJC_SELECTOR_REFERENCES_.2, align 8, !invariant.load !8
+  %7 = tail call i32 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i32 (i8*, i8*)*)(i8* %5, i8* %6) #5
+  ret void
+}
+
+; Function Attrs: nonlazybind
+declare i8* @objc_msgSend(i8*, i8*, ...) local_unnamed_addr #2
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01+[A meth3]"(i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01+[A meth4:]"(i8* nocapture, i8* nocapture, i32) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readonly ssp uwtable
+define internal i32 @"\01-[A prop1]"(%0* nocapture readonly, i8* nocapture readnone) #3 {
+  %3 = load i32, i32* @"OBJC_IVAR_$_A._prop1", align 8, !invariant.load !8
+  %4 = sext i32 %3 to i64
+  %5 = bitcast %0* %0 to i8*
+  %6 = getelementptr inbounds i8, i8* %5, i64 %4
+  %7 = bitcast i8* %6 to i32*
+  %8 = load atomic i32, i32* %7 unordered, align 4
+  ret i32 %8
+}
+
+; Function Attrs: norecurse nounwind optsize ssp uwtable
+define internal void @"\01-[A setProp1:]"(%0* nocapture, i8* nocapture readnone, i32) #4 {
+  %4 = load i32, i32* @"OBJC_IVAR_$_A._prop1", align 8, !invariant.load !8
+  %5 = sext i32 %4 to i64
+  %6 = bitcast %0* %0 to i8*
+  %7 = getelementptr inbounds i8, i8* %6, i64 %5
+  %8 = bitcast i8* %7 to i32*
+  store atomic i32 %2, i32* %8 unordered, align 4
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readonly ssp uwtable
+define internal i32 @"\01-[A prop2]"(%0* nocapture readonly, i8* nocapture readnone) #3 {
+  %3 = load i32, i32* @"OBJC_IVAR_$_A._prop2", align 8, !invariant.load !8
+  %4 = sext i32 %3 to i64
+  %5 = bitcast %0* %0 to i8*
+  %6 = getelementptr inbounds i8, i8* %5, i64 %4
+  %7 = bitcast i8* %6 to i32*
+  %8 = load atomic i32, i32* %7 unordered, align 4
+  ret i32 %8
+}
+
+; Function Attrs: norecurse nounwind optsize readonly ssp uwtable
+define internal i32 @"\01-[A isProp3]"(%0* nocapture readonly, i8* nocapture readnone) #3 {
+  %3 = load i32, i32* @"OBJC_IVAR_$_A._prop3", align 8, !invariant.load !8
+  %4 = sext i32 %3 to i64
+  %5 = bitcast %0* %0 to i8*
+  %6 = getelementptr inbounds i8, i8* %5, i64 %4
+  %7 = bitcast i8* %6 to i32*
+  %8 = load atomic i32, i32* %7 unordered, align 4
+  ret i32 %8
+}
+
+; Function Attrs: norecurse nounwind optsize ssp uwtable
+define internal void @"\01-[A setProp3:]"(%0* nocapture, i8* nocapture readnone, i32) #4 {
+  %4 = load i32, i32* @"OBJC_IVAR_$_A._prop3", align 8, !invariant.load !8
+  %5 = sext i32 %4 to i64
+  %6 = bitcast %0* %0 to i8*
+  %7 = getelementptr inbounds i8, i8* %6, i64 %5
+  %8 = bitcast i8* %7 to i32*
+  store atomic i32 %2, i32* %8 unordered, align 4
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readonly ssp uwtable
+define internal i32 @"\01-[A prop4]"(%0* nocapture readonly, i8* nocapture readnone) #3 {
+  %3 = load i32, i32* @"OBJC_IVAR_$_A._prop4", align 8, !invariant.load !8
+  %4 = sext i32 %3 to i64
+  %5 = bitcast %0* %0 to i8*
+  %6 = getelementptr inbounds i8, i8* %5, i64 %4
+  %7 = bitcast i8* %6 to i32*
+  %8 = load atomic i32, i32* %7 unordered, align 4
+  ret i32 %8
+}
+
+; Function Attrs: norecurse nounwind optsize ssp uwtable
+define internal void @"\01-[A prop4To:]"(%0* nocapture, i8* nocapture readnone, i32) #4 {
+  %4 = load i32, i32* @"OBJC_IVAR_$_A._prop4", align 8, !invariant.load !8
+  %5 = sext i32 %4 to i64
+  %6 = bitcast %0* %0 to i8*
+  %7 = getelementptr inbounds i8, i8* %6, i64 %5
+  %8 = bitcast i8* %7 to i32*
+  store atomic i32 %2, i32* %8 unordered, align 4
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[B method]"(%1* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[A(C) catMethod1]"(%0* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01+[A(C) catMethod2]"(i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: optsize ssp uwtable
+define internal void @"\01-[A(C) catMethod3:]"(%0* nocapture readnone, i8* nocapture readnone, %2*) #1 {
+  %4 = load i8*, i8** @OBJC_SELECTOR_REFERENCES_.31, align 8, !invariant.load !8
+  %5 = bitcast %2* %2 to i8*
+  tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*)*)(i8* %5, i8* %4) #5
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[A(C1) catMethod3]"(%0* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[PA protoMethod1]"(%3* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[PA protoMethod2:]"(%3* nocapture, i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01+[PA protoMethod3]"(i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[PB protoMethod7]"(%4* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define i32 @main() local_unnamed_addr #0 {
+  ret i32 0
+}
+
+attributes #0 = { norecurse nounwind optsize readnone ssp uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="cyclone" "target-features"="+crypto,+fp-armv8,+neon,+zcm,+zcz" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { optsize ssp uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="cyclone" "target-features"="+crypto,+fp-armv8,+neon,+zcm,+zcz" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #2 = { nonlazybind }
+attributes #3 = { norecurse nounwind optsize readonly ssp uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="cyclone" "target-features"="+crypto,+fp-armv8,+neon,+zcm,+zcz" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #4 = { norecurse nounwind optsize ssp uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="cyclone" "target-features"="+crypto,+fp-armv8,+neon,+zcm,+zcz" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #5 = { optsize }
+
+!llvm.module.flags = !{!0, !1, !2, !3, !4, !5, !6}
+!llvm.ident = !{!7}
+
+!0 = !{i32 1, !"Objective-C Version", i32 2}
+!1 = !{i32 1, !"Objective-C Image Info Version", i32 0}
+!2 = !{i32 1, !"Objective-C Image Info Section", !"__DATA,__objc_imageinfo,regular,no_dead_strip"}
+!3 = !{i32 4, !"Objective-C Garbage Collection", i32 0}
+!4 = !{i32 1, !"Objective-C Class Properties", i32 64}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{i32 7, !"PIC Level", i32 2}
+!7 = !{!"Apple LLVM version 10.0.0 (clang-1000.11.45.1)"}
+!8 = !{}

llvm/test/Object/ObjCMetadata/objc-metadata-i386.ll

+; objc1 metadata is not support for bitcode, check object file format
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: llvm-objc-metadata %t.o | FileCheck %s
+; CHECK: Objective-C Classes:
+; CHECK: # A :
+; CHECK:   instance method: meth1
+; CHECK:   instance method: meth2:
+; CHECK:   class method: meth3
+; CHECK:   class method: meth4:
+; CHECK: # B : A
+; CHECK:   instance method: method
+; CHECK: # PA : A
+; CHECK:   instance method: protoMethod1
+; CHECK:   instance method: protoMethod2:
+; CHECK:   class method: protoMethod3
+; CHECK: # PB : E
+; CHECK:   instance method: protoMethod7
+; CHECK: Objective-C Protocols:
+; CHECK: Objective-C Categories:
+; CHECK: # A(C)
+; CHECK:   instance method: catMethod1
+; CHECK:   instance method: catMethod3:
+; CHECK:   class method: catMethod2
+; CHECK: # A(C1)
+; CHECK:   instance method: catMethod3
+
+; ModuleID = 'Inputs/objc-metadata.m'
+source_filename = "Inputs/objc-metadata.m"
+target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128"
+target triple = "i386-apple-macosx10.12.0"
+
+module asm "\09.objc_class_name_A=0"
+module asm "\09.globl .objc_class_name_A"
+module asm "\09.objc_class_name_B=0"
+module asm "\09.globl .objc_class_name_B"
+module asm "\09.objc_class_name_PA=0"
+module asm "\09.globl .objc_class_name_PA"
+module asm "\09.objc_class_name_PB=0"
+module asm "\09.globl .objc_class_name_PB"
+module asm "\09.lazy_reference .objc_class_name_A"
+module asm "\09.lazy_reference .objc_class_name_Protocol"
+module asm "\09.lazy_reference .objc_class_name_E"
+module asm "\09.objc_category_name_A_C=0"
+module asm "\09.globl .objc_category_name_A_C"
+module asm "\09.objc_category_name_A_C1=0"
+module asm "\09.globl .objc_category_name_A_C1"
+
+%0 = type opaque
+%1 = type opaque
+%2 = type opaque
+%3 = type opaque
+%4 = type opaque
+%struct._objc_method = type { i8*, i8*, i8* }
+%struct._objc_class = type { %struct._objc_class*, %struct._objc_class*, i8*, i32, i32, i32, %struct._objc_ivar_list*, %struct._objc_method_list*, %struct._objc_cache*, %struct._objc_protocol_list*, i8*, %struct._objc_class_extension* }
+%struct._objc_ivar_list = type opaque
+%struct._objc_method_list = type opaque
+%struct._objc_cache = type opaque
+%struct._objc_protocol_list = type { %struct._objc_protocol_list*, i32, [0 x %struct._objc_protocol] }
+%struct._objc_protocol = type { %struct._objc_protocol_extension*, i8*, %struct._objc_protocol_list*, %struct._objc_method_description_list*, %struct._objc_method_description_list* }
+%struct._objc_protocol_extension = type { i32, %struct._objc_method_description_list*, %struct._objc_method_description_list*, %struct._prop_list_t*, i8**, %struct._prop_list_t* }
+%struct._prop_list_t = type { i32, i32, [0 x %struct._prop_t] }
+%struct._prop_t = type { i8*, i8* }
+%struct._objc_method_description_list = type { i32, [0 x %struct._objc_method_description] }
+%struct._objc_method_description = type { i8*, i8* }
+%struct._objc_class_extension = type { i32, i8*, %struct._prop_list_t* }
+%struct._objc_category = type { i8*, i8*, %struct._objc_method_list*, %struct._objc_method_list*, %struct._objc_protocol_list*, i32, %struct._prop_list_t*, %struct._prop_list_t* }
+%struct._objc_module = type { i32, i32, i8*, %struct._objc_symtab* }
+%struct._objc_symtab = type { i32, i8*, i16, i16, [0 x i8*] }
+
+@OBJC_METH_VAR_NAME_ = private global [6 x i8] c"meth1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_SELECTOR_REFERENCES_ = private externally_initialized global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_, i32 0, i32 0), section "__OBJC,__message_refs,literal_pointers,no_dead_strip", align 4
+@OBJC_METH_VAR_NAME_.1 = private global [6 x i8] c"prop1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_SELECTOR_REFERENCES_.2 = private externally_initialized global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.1, i32 0, i32 0), section "__OBJC,__message_refs,literal_pointers,no_dead_strip", align 4
+@OBJC_METH_VAR_TYPE_ = private global [7 x i8] c"v8@0:4\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.3 = private global [7 x i8] c"meth2:\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_.4 = private global [10 x i8] c"v12@0:4i8\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.5 = private global [6 x i8] c"meth3\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.6 = private global [7 x i8] c"meth4:\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_CLASS_NAME_ = private global [2 x i8] c"A\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_CLASS_METHODS_A = private global { i8*, i32, [2 x %struct._objc_method] } { i8* null, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.5, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (i8*, i8*)* @"\01+[A meth3]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.6, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_TYPE_.4, i32 0, i32 0), i8* bitcast (void (i8*, i8*, i32)* @"\01+[A meth4:]" to i8*) }] }, section "__OBJC,__cls_meth,regular,no_dead_strip", align 4
+@OBJC_METACLASS_A = private global %struct._objc_class { %struct._objc_class* bitcast ([2 x i8]* @OBJC_CLASS_NAME_ to %struct._objc_class*), %struct._objc_class* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_, i32 0, i32 0), i32 0, i32 2, i32 48, %struct._objc_ivar_list* null, %struct._objc_method_list* bitcast ({ i8*, i32, [2 x %struct._objc_method] }* @OBJC_CLASS_METHODS_A to %struct._objc_method_list*), %struct._objc_cache* null, %struct._objc_protocol_list* null, i8* null, %struct._objc_class_extension* null }, section "__OBJC,__meta_class,regular,no_dead_strip", align 4
+@OBJC_INSTANCE_METHODS_A = private global { i8*, i32, [2 x %struct._objc_method] } { i8* null, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%0*, i8*)* @"\01-[A meth1]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.3, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_TYPE_.4, i32 0, i32 0), i8* bitcast (void (%0*, i8*, i32)* @"\01-[A meth2:]" to i8*) }] }, section "__OBJC,__inst_meth,regular,no_dead_strip", align 4
+@OBJC_PROP_NAME_ATTR_ = private global [6 x i8] c"prop1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.7 = private global [3 x i8] c"Ti\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.8 = private global [6 x i8] c"prop2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.9 = private global [5 x i8] c"Ti,R\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.10 = private global [6 x i8] c"prop3\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.11 = private global [12 x i8] c"Ti,GisProp3\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.12 = private global [6 x i8] c"prop4\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.13 = private global [13 x i8] c"Ti,Sprop4To:\00", section "__TEXT,__cstring,cstring_literals", align 1
+@"\01l_OBJC_$_PROP_LIST_A" = private global { i32, i32, [4 x %struct._prop_t] } { i32 8, i32 4, [4 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_PROP_NAME_ATTR_.7, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.8, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.9, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.10, i32 0, i32 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @OBJC_PROP_NAME_ATTR_.11, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.12, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_PROP_NAME_ATTR_.13, i32 0, i32 0) }] }, section "__OBJC,__property,regular,no_dead_strip", align 4
+@OBJC_CLASSEXT_A = private global %struct._objc_class_extension { i32 12, i8* null, %struct._prop_list_t* bitcast ({ i32, i32, [4 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A" to %struct._prop_list_t*) }, section "__OBJC,__class_ext,regular,no_dead_strip", align 4
+@OBJC_CLASS_A = private global %struct._objc_class { %struct._objc_class* @OBJC_METACLASS_A, %struct._objc_class* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_, i32 0, i32 0), i32 0, i32 1, i32 0, %struct._objc_ivar_list* null, %struct._objc_method_list* bitcast ({ i8*, i32, [2 x %struct._objc_method] }* @OBJC_INSTANCE_METHODS_A to %struct._objc_method_list*), %struct._objc_cache* null, %struct._objc_protocol_list* null, i8* null, %struct._objc_class_extension* @OBJC_CLASSEXT_A }, section "__OBJC,__class,regular,no_dead_strip", align 4
+@OBJC_METH_VAR_NAME_.14 = private global [7 x i8] c"method\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_CLASS_NAME_.15 = private global [2 x i8] c"B\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METACLASS_B = private global %struct._objc_class { %struct._objc_class* bitcast ([2 x i8]* @OBJC_CLASS_NAME_ to %struct._objc_class*), %struct._objc_class* bitcast ([2 x i8]* @OBJC_CLASS_NAME_ to %struct._objc_class*), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.15, i32 0, i32 0), i32 0, i32 2, i32 48, %struct._objc_ivar_list* null, %struct._objc_method_list* null, %struct._objc_cache* null, %struct._objc_protocol_list* null, i8* null, %struct._objc_class_extension* null }, section "__OBJC,__meta_class,regular,no_dead_strip", align 4
+@OBJC_INSTANCE_METHODS_B = private global { i8*, i32, [1 x %struct._objc_method] } { i8* null, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.14, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%1*, i8*)* @"\01-[B method]" to i8*) }] }, section "__OBJC,__inst_meth,regular,no_dead_strip", align 4
+@OBJC_CLASS_B = private global %struct._objc_class { %struct._objc_class* @OBJC_METACLASS_B, %struct._objc_class* bitcast ([2 x i8]* @OBJC_CLASS_NAME_ to %struct._objc_class*), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.15, i32 0, i32 0), i32 0, i32 1, i32 0, %struct._objc_ivar_list* null, %struct._objc_method_list* bitcast ({ i8*, i32, [1 x %struct._objc_method] }* @OBJC_INSTANCE_METHODS_B to %struct._objc_method_list*), %struct._objc_cache* null, %struct._objc_protocol_list* null, i8* null, %struct._objc_class_extension* null }, section "__OBJC,__class,regular,no_dead_strip", align 4
+@OBJC_METH_VAR_NAME_.16 = private global [9 x i8] c"external\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_SELECTOR_REFERENCES_.17 = private externally_initialized global i8* getelementptr inbounds ([9 x i8], [9 x i8]* @OBJC_METH_VAR_NAME_.16, i32 0, i32 0), section "__OBJC,__message_refs,literal_pointers,no_dead_strip", align 4
+@OBJC_METH_VAR_NAME_.18 = private global [11 x i8] c"catMethod1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.19 = private global [12 x i8] c"catMethod3:\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_.20 = private global [10 x i8] c"v12@0:4@8\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.21 = private global [11 x i8] c"catMethod2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_CLASS_NAME_.22 = private global [2 x i8] c"C\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_CATEGORY_INSTANCE_METHODS_A_C = private global { i8*, i32, [2 x %struct._objc_method] } { i8* null, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.18, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%0*, i8*)* @"\01-[A(C) catMethod1]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([12 x i8], [12 x i8]* @OBJC_METH_VAR_NAME_.19, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_TYPE_.20, i32 0, i32 0), i8* bitcast (void (%0*, i8*, %2*)* @"\01-[A(C) catMethod3:]" to i8*) }] }, section "__OBJC,__cat_inst_meth,regular,no_dead_strip", align 4
+@OBJC_CATEGORY_CLASS_METHODS_A_C = private global { i8*, i32, [1 x %struct._objc_method] } { i8* null, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.21, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (i8*, i8*)* @"\01+[A(C) catMethod2]" to i8*) }] }, section "__OBJC,__cat_cls_meth,regular,no_dead_strip", align 4
+@OBJC_PROP_NAME_ATTR_.23 = private global [4 x i8] c"cp1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.24 = private global [5 x i8] c"Ti,D\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.25 = private global [4 x i8] c"cp2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@"\01l_OBJC_$_PROP_LIST_A_C" = private global { i32, i32, [2 x %struct._prop_t] } { i32 8, i32 2, [2 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.23, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.24, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.25, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.24, i32 0, i32 0) }] }, section "__OBJC,__property,regular,no_dead_strip", align 4
+@OBJC_CATEGORY_A_C = private global %struct._objc_category { i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.22, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_, i32 0, i32 0), %struct._objc_method_list* bitcast ({ i8*, i32, [2 x %struct._objc_method] }* @OBJC_CATEGORY_INSTANCE_METHODS_A_C to %struct._objc_method_list*), %struct._objc_method_list* bitcast ({ i8*, i32, [1 x %struct._objc_method] }* @OBJC_CATEGORY_CLASS_METHODS_A_C to %struct._objc_method_list*), %struct._objc_protocol_list* null, i32 32, %struct._prop_list_t* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A_C" to %struct._prop_list_t*), %struct._prop_list_t* null }, section "__OBJC,__category,regular,no_dead_strip", align 4
+@OBJC_METH_VAR_NAME_.26 = private global [11 x i8] c"catMethod3\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_CLASS_NAME_.27 = private global [3 x i8] c"C1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_CATEGORY_INSTANCE_METHODS_A_C1 = private global { i8*, i32, [1 x %struct._objc_method] } { i8* null, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.26, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%0*, i8*)* @"\01-[A(C1) catMethod3]" to i8*) }] }, section "__OBJC,__cat_inst_meth,regular,no_dead_strip", align 4
+@OBJC_CATEGORY_A_C1 = private global %struct._objc_category { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.27, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_, i32 0, i32 0), %struct._objc_method_list* bitcast ({ i8*, i32, [1 x %struct._objc_method] }* @OBJC_CATEGORY_INSTANCE_METHODS_A_C1 to %struct._objc_method_list*), %struct._objc_method_list* null, %struct._objc_protocol_list* null, i32 32, %struct._prop_list_t* null, %struct._prop_list_t* null }, section "__OBJC,__category,regular,no_dead_strip", align 4
+@OBJC_METH_VAR_NAME_.28 = private global [13 x i8] c"protoMethod1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.29 = private global [14 x i8] c"protoMethod2:\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.30 = private global [13 x i8] c"protoMethod4\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.31 = private global [14 x i8] c"protoMethod5:\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.32 = private global [4 x i8] c"pp1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_.33 = private global [7 x i8] c"i8@0:4\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.34 = private global [8 x i8] c"setPp1:\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.35 = private global [4 x i8] c"pp2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.36 = private global [8 x i8] c"setPp2:\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.37 = private global [13 x i8] c"protoMethod3\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.38 = private global [13 x i8] c"protoMethod6\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROTOCOL_INSTANCE_METHODS_OPT_P = private global { i32, [2 x %struct._objc_method_description] } { i32 2, [2 x %struct._objc_method_description] [%struct._objc_method_description { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.30, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0) }, %struct._objc_method_description { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.31, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_TYPE_.20, i32 0, i32 0) }] }, section "__OBJC,__cat_inst_meth,regular,no_dead_strip", align 4
+@OBJC_PROTOCOL_CLASS_METHODS_OPT_P = private global { i32, [1 x %struct._objc_method_description] } { i32 1, [1 x %struct._objc_method_description] [%struct._objc_method_description { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.38, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0) }] }, section "__OBJC,__cat_cls_meth,regular,no_dead_strip", align 4
+@OBJC_PROP_NAME_ATTR_.39 = private global [4 x i8] c"pp1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.40 = private global [4 x i8] c"pp2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@"OBJC_$_PROP_PROTO_LIST_P" = private global { i32, i32, [2 x %struct._prop_t] } { i32 8, i32 2, [2 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.39, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_PROP_NAME_ATTR_.7, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.40, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_PROP_NAME_ATTR_.7, i32 0, i32 0) }] }, section "__OBJC,__property,regular,no_dead_strip", align 4
+@OBJC_PROTOCOL_METHOD_TYPES_P = private global [10 x i8*] [i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_TYPE_.20, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_.33, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_TYPE_.4, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_.33, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_TYPE_.4, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_TYPE_.20, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0)], align 4
+@"\01l_OBJC_PROTOCOLEXT_P" = private global %struct._objc_protocol_extension { i32 24, %struct._objc_method_description_list* bitcast ({ i32, [2 x %struct._objc_method_description] }* @OBJC_PROTOCOL_INSTANCE_METHODS_OPT_P to %struct._objc_method_description_list*), %struct._objc_method_description_list* bitcast ({ i32, [1 x %struct._objc_method_description] }* @OBJC_PROTOCOL_CLASS_METHODS_OPT_P to %struct._objc_method_description_list*), %struct._prop_list_t* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"OBJC_$_PROP_PROTO_LIST_P" to %struct._prop_list_t*), i8** getelementptr inbounds ([10 x i8*], [10 x i8*]* @OBJC_PROTOCOL_METHOD_TYPES_P, i32 0, i32 0), %struct._prop_list_t* null }, align 4
+@OBJC_CLASS_NAME_.41 = private global [2 x i8] c"P\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROTOCOL_INSTANCE_METHODS_P = private global { i32, [6 x %struct._objc_method_description] } { i32 6, [6 x %struct._objc_method_description] [%struct._objc_method_description { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.28, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0) }, %struct._objc_method_description { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.29, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_TYPE_.20, i32 0, i32 0) }, %struct._objc_method_description { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.32, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_.33, i32 0, i32 0) }, %struct._objc_method_description { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.34, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_TYPE_.4, i32 0, i32 0) }, %struct._objc_method_description { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.35, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_.33, i32 0, i32 0) }, %struct._objc_method_description { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.36, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_TYPE_.4, i32 0, i32 0) }] }, section "__OBJC,__cat_inst_meth,regular,no_dead_strip", align 4
+@OBJC_PROTOCOL_CLASS_METHODS_P = private global { i32, [1 x %struct._objc_method_description] } { i32 1, [1 x %struct._objc_method_description] [%struct._objc_method_description { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.37, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0) }] }, section "__OBJC,__cat_cls_meth,regular,no_dead_strip", align 4
+@OBJC_PROTOCOL_P = private global %struct._objc_protocol { %struct._objc_protocol_extension* @"\01l_OBJC_PROTOCOLEXT_P", i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.41, i32 0, i32 0), %struct._objc_protocol_list* null, %struct._objc_method_description_list* bitcast ({ i32, [6 x %struct._objc_method_description] }* @OBJC_PROTOCOL_INSTANCE_METHODS_P to %struct._objc_method_description_list*), %struct._objc_method_description_list* bitcast ({ i32, [1 x %struct._objc_method_description] }* @OBJC_PROTOCOL_CLASS_METHODS_P to %struct._objc_method_description_list*) }, section "__OBJC,__protocol,regular,no_dead_strip", align 4
+@OBJC_CLASS_PROTOCOLS_PA = private global { %struct._objc_protocol_list*, i32, [2 x %struct._objc_protocol*] } { %struct._objc_protocol_list* null, i32 1, [2 x %struct._objc_protocol*] [%struct._objc_protocol* @OBJC_PROTOCOL_P, %struct._objc_protocol* null] }, section "__OBJC,__cat_cls_meth,regular,no_dead_strip", align 4
+@OBJC_CLASS_NAME_.42 = private global [3 x i8] c"PA\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_CLASS_METHODS_PA = private global { i8*, i32, [1 x %struct._objc_method] } { i8* null, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.37, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (i8*, i8*)* @"\01+[PA protoMethod3]" to i8*) }] }, section "__OBJC,__cls_meth,regular,no_dead_strip", align 4
+@OBJC_METACLASS_PA = private global %struct._objc_class { %struct._objc_class* bitcast ([2 x i8]* @OBJC_CLASS_NAME_ to %struct._objc_class*), %struct._objc_class* bitcast ([2 x i8]* @OBJC_CLASS_NAME_ to %struct._objc_class*), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.42, i32 0, i32 0), i32 0, i32 2, i32 48, %struct._objc_ivar_list* null, %struct._objc_method_list* bitcast ({ i8*, i32, [1 x %struct._objc_method] }* @OBJC_CLASS_METHODS_PA to %struct._objc_method_list*), %struct._objc_cache* null, %struct._objc_protocol_list* bitcast ({ %struct._objc_protocol_list*, i32, [2 x %struct._objc_protocol*] }* @OBJC_CLASS_PROTOCOLS_PA to %struct._objc_protocol_list*), i8* null, %struct._objc_class_extension* null }, section "__OBJC,__meta_class,regular,no_dead_strip", align 4
+@OBJC_INSTANCE_METHODS_PA = private global { i8*, i32, [2 x %struct._objc_method] } { i8* null, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.28, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%3*, i8*)* @"\01-[PA protoMethod1]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.29, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_TYPE_.20, i32 0, i32 0), i8* bitcast (void (%3*, i8*, i8*)* @"\01-[PA protoMethod2:]" to i8*) }] }, section "__OBJC,__inst_meth,regular,no_dead_strip", align 4
+@"\01l_OBJC_$_PROP_LIST_PA" = private global { i32, i32, [2 x %struct._prop_t] } { i32 8, i32 2, [2 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.39, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.24, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.40, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.24, i32 0, i32 0) }] }, section "__OBJC,__property,regular,no_dead_strip", align 4
+@OBJC_CLASSEXT_PA = private global %struct._objc_class_extension { i32 12, i8* null, %struct._prop_list_t* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_PA" to %struct._prop_list_t*) }, section "__OBJC,__class_ext,regular,no_dead_strip", align 4
+@OBJC_CLASS_PA = private global %struct._objc_class { %struct._objc_class* @OBJC_METACLASS_PA, %struct._objc_class* bitcast ([2 x i8]* @OBJC_CLASS_NAME_ to %struct._objc_class*), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.42, i32 0, i32 0), i32 0, i32 1, i32 0, %struct._objc_ivar_list* null, %struct._objc_method_list* bitcast ({ i8*, i32, [2 x %struct._objc_method] }* @OBJC_INSTANCE_METHODS_PA to %struct._objc_method_list*), %struct._objc_cache* null, %struct._objc_protocol_list* bitcast ({ %struct._objc_protocol_list*, i32, [2 x %struct._objc_protocol*] }* @OBJC_CLASS_PROTOCOLS_PA to %struct._objc_protocol_list*), i8* null, %struct._objc_class_extension* @OBJC_CLASSEXT_PA }, section "__OBJC,__class,regular,no_dead_strip", align 4
+@OBJC_METH_VAR_NAME_.43 = private global [13 x i8] c"protoMethod7\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROTOCOL_METHOD_TYPES_P2 = private global [1 x i8*] [i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0)], align 4
+@"\01l_OBJC_PROTOCOLEXT_P2" = private global %struct._objc_protocol_extension { i32 24, %struct._objc_method_description_list* null, %struct._objc_method_description_list* null, %struct._prop_list_t* null, i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @OBJC_PROTOCOL_METHOD_TYPES_P2, i32 0, i32 0), %struct._prop_list_t* null }, align 4
+@OBJC_CLASS_NAME_.44 = private global [3 x i8] c"P2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROTOCOL_INSTANCE_METHODS_P2 = private global { i32, [1 x %struct._objc_method_description] } { i32 1, [1 x %struct._objc_method_description] [%struct._objc_method_description { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.43, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0) }] }, section "__OBJC,__cat_inst_meth,regular,no_dead_strip", align 4
+@OBJC_PROTOCOL_P2 = private global %struct._objc_protocol { %struct._objc_protocol_extension* @"\01l_OBJC_PROTOCOLEXT_P2", i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.44, i32 0, i32 0), %struct._objc_protocol_list* null, %struct._objc_method_description_list* bitcast ({ i32, [1 x %struct._objc_method_description] }* @OBJC_PROTOCOL_INSTANCE_METHODS_P2 to %struct._objc_method_description_list*), %struct._objc_method_description_list* null }, section "__OBJC,__protocol,regular,no_dead_strip", align 4
+@OBJC_CLASS_PROTOCOLS_PB = private global { %struct._objc_protocol_list*, i32, [2 x %struct._objc_protocol*] } { %struct._objc_protocol_list* null, i32 1, [2 x %struct._objc_protocol*] [%struct._objc_protocol* @OBJC_PROTOCOL_P2, %struct._objc_protocol* null] }, section "__OBJC,__cat_cls_meth,regular,no_dead_strip", align 4
+@OBJC_CLASS_NAME_.45 = private global [2 x i8] c"E\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_CLASS_NAME_.46 = private global [3 x i8] c"PB\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_METACLASS_PB = private global %struct._objc_class { %struct._objc_class* bitcast ([2 x i8]* @OBJC_CLASS_NAME_.45 to %struct._objc_class*), %struct._objc_class* bitcast ([2 x i8]* @OBJC_CLASS_NAME_.45 to %struct._objc_class*), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.46, i32 0, i32 0), i32 0, i32 2, i32 48, %struct._objc_ivar_list* null, %struct._objc_method_list* null, %struct._objc_cache* null, %struct._objc_protocol_list* bitcast ({ %struct._objc_protocol_list*, i32, [2 x %struct._objc_protocol*] }* @OBJC_CLASS_PROTOCOLS_PB to %struct._objc_protocol_list*), i8* null, %struct._objc_class_extension* null }, section "__OBJC,__meta_class,regular,no_dead_strip", align 4
+@OBJC_INSTANCE_METHODS_PB = private global { i8*, i32, [1 x %struct._objc_method] } { i8* null, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.43, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%4*, i8*)* @"\01-[PB protoMethod7]" to i8*) }] }, section "__OBJC,__inst_meth,regular,no_dead_strip", align 4
+@OBJC_CLASS_PB = private global %struct._objc_class { %struct._objc_class* @OBJC_METACLASS_PB, %struct._objc_class* bitcast ([2 x i8]* @OBJC_CLASS_NAME_.45 to %struct._objc_class*), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.46, i32 0, i32 0), i32 0, i32 1, i32 0, %struct._objc_ivar_list* null, %struct._objc_method_list* bitcast ({ i8*, i32, [1 x %struct._objc_method] }* @OBJC_INSTANCE_METHODS_PB to %struct._objc_method_list*), %struct._objc_cache* null, %struct._objc_protocol_list* bitcast ({ %struct._objc_protocol_list*, i32, [2 x %struct._objc_protocol*] }* @OBJC_CLASS_PROTOCOLS_PB to %struct._objc_protocol_list*), i8* null, %struct._objc_class_extension* null }, section "__OBJC,__class,regular,no_dead_strip", align 4
+@OBJC_CLASS_NAME_.47 = private global [1 x i8] zeroinitializer, section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_SYMBOLS = private global { i32, i8*, i16, i16, [6 x i8*] } { i32 0, i8* null, i16 4, i16 2, [6 x i8*] [i8* bitcast (%struct._objc_class* @OBJC_CLASS_A to i8*), i8* bitcast (%struct._objc_class* @OBJC_CLASS_B to i8*), i8* bitcast (%struct._objc_class* @OBJC_CLASS_PA to i8*), i8* bitcast (%struct._objc_class* @OBJC_CLASS_PB to i8*), i8* bitcast (%struct._objc_category* @OBJC_CATEGORY_A_C to i8*), i8* bitcast (%struct._objc_category* @OBJC_CATEGORY_A_C1 to i8*)] }, section "__OBJC,__symbols,regular,no_dead_strip", align 4
+@OBJC_MODULES = private global %struct._objc_module { i32 7, i32 16, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @OBJC_CLASS_NAME_.47, i32 0, i32 0), %struct._objc_symtab* bitcast ({ i32, i8*, i16, i16, [6 x i8*] }* @OBJC_SYMBOLS to %struct._objc_symtab*) }, section "__OBJC,__module_info,regular,no_dead_strip", align 4
[e-mail] = appending global [90 x i8*] [i8* bitcast ({ i32, i32, [4 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A_C" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_PA" to i8*), i8* bitcast (%struct._objc_protocol_extension* @"\01l_OBJC_PROTOCOLEXT_P" to i8*), i8* bitcast (%struct._objc_protocol_extension* @"\01l_OBJC_PROTOCOLEXT_P2" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"OBJC_$_PROP_PROTO_LIST_P" to i8*), i8* bitcast (%struct._objc_category* @OBJC_CATEGORY_A_C to i8*), i8* bitcast (%struct._objc_category* @OBJC_CATEGORY_A_C1 to i8*), i8* bitcast ({ i8*, i32, [1 x %struct._objc_method] }* @OBJC_CATEGORY_CLASS_METHODS_A_C to i8*), i8* bitcast ({ i8*, i32, [2 x %struct._objc_method] }* @OBJC_CATEGORY_INSTANCE_METHODS_A_C to i8*), i8* bitcast ({ i8*, i32, [1 x %struct._objc_method] }* @OBJC_CATEGORY_INSTANCE_METHODS_A_C1 to i8*), i8* bitcast (%struct._objc_class_extension* @OBJC_CLASSEXT_A to i8*), i8* bitcast (%struct._objc_class_extension* @OBJC_CLASSEXT_PA to i8*), i8* bitcast (%struct._objc_class* @OBJC_CLASS_A to i8*), i8* bitcast (%struct._objc_class* @OBJC_CLASS_B to i8*), i8* bitcast ({ i8*, i32, [2 x %struct._objc_method] }* @OBJC_CLASS_METHODS_A to i8*), i8* bitcast ({ i8*, i32, [1 x %struct._objc_method] }* @OBJC_CLASS_METHODS_PA to i8*), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.15, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.22, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.27, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.41, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.42, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.44, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.45, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.46, i32 0, i32 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @OBJC_CLASS_NAME_.47, i32 0, i32 0), i8* bitcast (%struct._objc_class* @OBJC_CLASS_PA to i8*), i8* bitcast (%struct._objc_class* @OBJC_CLASS_PB to i8*), i8* bitcast ({ i8*, i32, [2 x %struct._objc_method] }* @OBJC_INSTANCE_METHODS_A to i8*), i8* bitcast ({ i8*, i32, [1 x %struct._objc_method] }* @OBJC_INSTANCE_METHODS_B to i8*), i8* bitcast ({ i8*, i32, [2 x %struct._objc_method] }* @OBJC_INSTANCE_METHODS_PA to i8*), i8* bitcast ({ i8*, i32, [1 x %struct._objc_method] }* @OBJC_INSTANCE_METHODS_PB to i8*), i8* bitcast (%struct._objc_class* @OBJC_METACLASS_A to i8*), i8* bitcast (%struct._objc_class* @OBJC_METACLASS_B to i8*), i8* bitcast (%struct._objc_class* @OBJC_METACLASS_PA to i8*), i8* bitcast (%struct._objc_class* @OBJC_METACLASS_PB to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.1, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.14, i32 0, i32 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @OBJC_METH_VAR_NAME_.16, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.18, i32 0, i32 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @OBJC_METH_VAR_NAME_.19, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.21, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.26, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.28, i32 0, i32 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.29, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.3, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.30, i32 0, i32 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.31, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.32, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.34, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.35, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.36, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.37, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.38, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.43, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.5, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.6, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_TYPE_.20, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_TYPE_.33, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_TYPE_.4, i32 0, i32 0), i8* bitcast (%struct._objc_module* @OBJC_MODULES to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.10, i32 0, i32 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @OBJC_PROP_NAME_ATTR_.11, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.12, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_PROP_NAME_ATTR_.13, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.23, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.24, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.25, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.39, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.40, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_PROP_NAME_ATTR_.7, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.8, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.9, i32 0, i32 0), i8* bitcast ({ i32, [1 x %struct._objc_method_description] }* @OBJC_PROTOCOL_CLASS_METHODS_OPT_P to i8*), i8* bitcast ({ i32, [1 x %struct._objc_method_description] }* @OBJC_PROTOCOL_CLASS_METHODS_P to i8*), i8* bitcast ({ i32, [2 x %struct._objc_method_description] }* @OBJC_PROTOCOL_INSTANCE_METHODS_OPT_P to i8*), i8* bitcast ({ i32, [6 x %struct._objc_method_description] }* @OBJC_PROTOCOL_INSTANCE_METHODS_P to i8*), i8* bitcast ({ i32, [1 x %struct._objc_method_description] }* @OBJC_PROTOCOL_INSTANCE_METHODS_P2 to i8*), i8* bitcast ([10 x i8*]* @OBJC_PROTOCOL_METHOD_TYPES_P to i8*), i8* bitcast ([1 x i8*]* @OBJC_PROTOCOL_METHOD_TYPES_P2 to i8*), i8* bitcast (%struct._objc_protocol* @OBJC_PROTOCOL_P to i8*), i8* bitcast (%struct._objc_protocol* @OBJC_PROTOCOL_P2 to i8*), i8* bitcast (i8** @OBJC_SELECTOR_REFERENCES_ to i8*), i8* bitcast (i8** @OBJC_SELECTOR_REFERENCES_.17 to i8*), i8* bitcast (i8** @OBJC_SELECTOR_REFERENCES_.2 to i8*), i8* bitcast ({ i32, i8*, i16, i16, [6 x i8*] }* @OBJC_SYMBOLS to i8*)], section "llvm.metadata"
+
+; Function Attrs: norecurse nounwind optsize readnone ssp
+define internal void @"\01-[A meth1]"(%0* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: nounwind optsize ssp
+define internal void @"\01-[A meth2:]"(%0*, i8* nocapture readnone, i32) #1 {
+  %4 = load i8*, i8** @OBJC_SELECTOR_REFERENCES_, align 4
+  %5 = bitcast %0* %0 to i8*
+  tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*)*)(i8* %5, i8* %4) #3
+  %6 = load i8*, i8** @OBJC_SELECTOR_REFERENCES_.2, align 4
+  %7 = tail call i32 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i32 (i8*, i8*)*)(i8* %5, i8* %6) #3
+  ret void
+}
+
+; Function Attrs: nonlazybind
+declare i8* @objc_msgSend(i8*, i8*, ...) local_unnamed_addr #2
+
+; Function Attrs: norecurse nounwind optsize readnone ssp
+define internal void @"\01+[A meth3]"(i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp
+define internal void @"\01+[A meth4:]"(i8* nocapture, i8* nocapture, i32) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp
+define internal void @"\01-[B method]"(%1* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp
+define internal void @"\01-[A(C) catMethod1]"(%0* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp
+define internal void @"\01+[A(C) catMethod2]"(i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: nounwind optsize ssp
+define internal void @"\01-[A(C) catMethod3:]"(%0* nocapture readnone, i8* nocapture readnone, %2*) #1 {
+  %4 = load i8*, i8** @OBJC_SELECTOR_REFERENCES_.17, align 4
+  %5 = bitcast %2* %2 to i8*
+  tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*)*)(i8* %5, i8* %4) #3
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp
+define internal void @"\01-[A(C1) catMethod3]"(%0* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp
+define internal void @"\01-[PA protoMethod1]"(%3* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp
+define internal void @"\01-[PA protoMethod2:]"(%3* nocapture, i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp
+define internal void @"\01+[PA protoMethod3]"(i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp
+define internal void @"\01-[PB protoMethod7]"(%4* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp
+define i32 @main() local_unnamed_addr #0 {
+  ret i32 0
+}
+
+attributes #0 = { norecurse nounwind optsize readnone ssp "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+fxsr,+mmx,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind optsize ssp "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+fxsr,+mmx,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #2 = { nonlazybind }
+attributes #3 = { nounwind optsize }
+
+!llvm.module.flags = !{!0, !1, !2, !3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = !{i32 1, !"Objective-C Version", i32 1}
+!1 = !{i32 1, !"Objective-C Image Info Version", i32 0}
+!2 = !{i32 1, !"Objective-C Image Info Section", !"__OBJC, __image_info,regular"}
+!3 = !{i32 4, !"Objective-C Garbage Collection", i32 0}
+!4 = !{i32 1, !"Objective-C Class Properties", i32 64}
+!5 = !{i32 1, !"PIC Level", i32 2}
+!6 = !{!"Apple LLVM version 8.1.0 (clang-802.0.13.2)"}

llvm/test/Object/ObjCMetadata/objc-metadata-x86_64.ll

+; RUN: llvm-objc-metadata %s | FileCheck %s
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: llvm-objc-metadata %t.o | FileCheck %s
+; CHECK: Objective-C Classes:
+; CHECK: # A :
+; CHECK:   instance method: meth1
+; CHECK:   instance method: meth2:
+; CHECK:   instance method: prop1
+; CHECK:   instance method: setProp1:
+; CHECK:   instance method: prop2
+; CHECK:   instance method: isProp3
+; CHECK:   instance method: setProp3:
+; CHECK:   instance method: prop4
+; CHECK:   instance method: prop4To:
+; CHECK:   class method: meth3
+; CHECK:   class method: meth4:
+; CHECK:   property: prop1
+; CHECK:   property: prop2
+; CHECK:   property: prop3
+; CHECK:   property: prop4
+; CHECK:   class property: prop5
+; CHECK: # B : A
+; CHECK:   instance method: method
+; CHECK: # PA : A
+; CHECK:   instance method: protoMethod1
+; CHECK:   instance method: protoMethod2:
+; CHECK:   class method: protoMethod3
+; CHECK:   property: pp1
+; CHECK:   property: pp2
+; CHECK: # PB : E
+; CHECK:   instance method: protoMethod7
+; CHECK: Objective-C Protocols:
+; CHECK: # P
+; CHECK:   instance method: protoMethod1
+; CHECK:   instance method: protoMethod2:
+; CHECK:   instance method: pp1
+; CHECK:   instance method: setPp1:
+; CHECK:   instance method: pp2
+; CHECK:   instance method: setPp2:
+; CHECK:   optional instance method: protoMethod4
+; CHECK:   optional instance method: protoMethod5:
+; CHECK:   class method: protoMethod3
+; CHECK:   optional class method: protoMethod6
+; CHECK:   property: pp1
+; CHECK:   property: pp2
+; CHECK: # P2
+; CHECK:   instance method: protoMethod7
+; CHECK: Objective-C Categories:
+; CHECK: # A(C)
+; CHECK:   instance method: catMethod1
+; CHECK:   instance method: catMethod3:
+; CHECK:   class method: catMethod2
+; CHECK:   property: cp1
+; CHECK:   property: cp2
+; CHECK: # A(C1)
+; CHECK:   instance method: catMethod3
+
+; ModuleID = 'objc-metadata.m'
+source_filename = "objc-metadata.m"
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.14.0"
+
+%0 = type opaque
+%1 = type opaque
+%2 = type opaque
+%3 = type opaque
+%4 = type opaque
+%struct._objc_cache = type opaque
+%struct._class_t = type { %struct._class_t*, %struct._class_t*, %struct._objc_cache*, i8* (i8*, i8*)**, %struct._class_ro_t* }
+%struct._class_ro_t = type { i32, i32, i32, i8*, i8*, %struct.__method_list_t*, %struct._objc_protocol_list*, %struct._ivar_list_t*, i8*, %struct._prop_list_t* }
+%struct.__method_list_t = type { i32, i32, [0 x %struct._objc_method] }
+%struct._objc_method = type { i8*, i8*, i8* }
+%struct._objc_protocol_list = type { i64, [0 x %struct._protocol_t*] }
+%struct._protocol_t = type { i8*, i8*, %struct._objc_protocol_list*, %struct.__method_list_t*, %struct.__method_list_t*, %struct.__method_list_t*, %struct.__method_list_t*, %struct._prop_list_t*, i32, i32, i8**, i8*, %struct._prop_list_t* }
+%struct._ivar_list_t = type { i32, i32, [0 x %struct._ivar_t] }
+%struct._ivar_t = type { i64*, i8*, i8*, i32, i32 }
+%struct._prop_list_t = type { i32, i32, [0 x %struct._prop_t] }
+%struct._prop_t = type { i8*, i8* }
+%struct._category_t = type { i8*, %struct._class_t*, %struct.__method_list_t*, %struct.__method_list_t*, %struct._objc_protocol_list*, %struct._prop_list_t*, %struct._prop_list_t*, i32 }
+
+@OBJC_METH_VAR_NAME_ = private unnamed_addr constant [6 x i8] c"meth1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_SELECTOR_REFERENCES_ = private externally_initialized global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_, i64 0, i64 0), section "__DATA,__objc_selrefs,literal_pointers,no_dead_strip", align 8
+@OBJC_METH_VAR_NAME_.1 = private unnamed_addr constant [6 x i8] c"prop1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_SELECTOR_REFERENCES_.2 = private externally_initialized global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.1, i64 0, i64 0), section "__DATA,__objc_selrefs,literal_pointers,no_dead_strip", align 8
+@"OBJC_IVAR_$_A._prop1" = hidden global i64 0, section "__DATA, __objc_ivar", align 8
+@"OBJC_IVAR_$_A._prop2" = hidden global i64 4, section "__DATA, __objc_ivar", align 8
+@"OBJC_IVAR_$_A._prop3" = hidden global i64 8, section "__DATA, __objc_ivar", align 8
+@"OBJC_IVAR_$_A._prop4" = hidden global i64 12, section "__DATA, __objc_ivar", align 8
+@_objc_empty_cache = external global %struct._objc_cache
+@"OBJC_CLASS_$_A" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_A", %struct._class_t* null, %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_CLASS_RO_$_A" }, section "__DATA, __objc_data", align 8
+@"OBJC_METACLASS_$_A" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_A", %struct._class_t* @"OBJC_CLASS_$_A", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_METACLASS_RO_$_A" }, section "__DATA, __objc_data", align 8
+@OBJC_CLASS_NAME_ = private unnamed_addr constant [2 x i8] c"A\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.3 = private unnamed_addr constant [6 x i8] c"meth3\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_ = private unnamed_addr constant [8 x i8] c"v16@0:8\00", section "__TEXT,__objc_methtype,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.4 = private unnamed_addr constant [7 x i8] c"meth4:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_.5 = private unnamed_addr constant [11 x i8] c"v20@0:8i16\00", section "__TEXT,__objc_methtype,cstring_literals", align 1
+@"\01l_OBJC_$_CLASS_METHODS_A" = private global { i32, i32, [2 x %struct._objc_method] } { i32 24, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.3, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (i8*, i8*)* @"\01+[A meth3]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.4, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* bitcast (void (i8*, i8*, i32)* @"\01+[A meth4:]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@OBJC_PROP_NAME_ATTR_ = private unnamed_addr constant [6 x i8] c"prop5\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.6 = private unnamed_addr constant [5 x i8] c"Ti,D\00", section "__TEXT,__cstring,cstring_literals", align 1
+@"\01l_OBJC_$_CLASS_PROP_LIST_A" = private global { i32, i32, [1 x %struct._prop_t] } { i32 16, i32 1, [1 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.6, i32 0, i32 0) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_METACLASS_RO_$_A" = private global %struct._class_ro_t { i32 3, i32 40, i32 40, i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_CLASS_METHODS_A" to %struct.__method_list_t*), %struct._objc_protocol_list* null, %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* bitcast ({ i32, i32, [1 x %struct._prop_t] }* @"\01l_OBJC_$_CLASS_PROP_LIST_A" to %struct._prop_list_t*) }, section "__DATA, __objc_const", align 8
+@OBJC_METH_VAR_NAME_.7 = private unnamed_addr constant [7 x i8] c"meth2:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_.8 = private unnamed_addr constant [8 x i8] c"i16@0:8\00", section "__TEXT,__objc_methtype,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.9 = private unnamed_addr constant [10 x i8] c"setProp1:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.10 = private unnamed_addr constant [6 x i8] c"prop2\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.11 = private unnamed_addr constant [8 x i8] c"isProp3\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.12 = private unnamed_addr constant [10 x i8] c"setProp3:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.13 = private unnamed_addr constant [6 x i8] c"prop4\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.14 = private unnamed_addr constant [9 x i8] c"prop4To:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_INSTANCE_METHODS_A" = private global { i32, i32, [9 x %struct._objc_method] } { i32 24, i32 9, [9 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%0*, i8*)* @"\01-[A meth1]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.7, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* bitcast (void (%0*, i8*, i32)* @"\01-[A meth2:]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.1, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* bitcast (i32 (%0*, i8*)* @"\01-[A prop1]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_NAME_.9, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* bitcast (void (%0*, i8*, i32)* @"\01-[A setProp1:]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.10, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* bitcast (i32 (%0*, i8*)* @"\01-[A prop2]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.11, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* bitcast (i32 (%0*, i8*)* @"\01-[A isProp3]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_NAME_.12, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* bitcast (void (%0*, i8*, i32)* @"\01-[A setProp3:]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.13, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* bitcast (i32 (%0*, i8*)* @"\01-[A prop4]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @OBJC_METH_VAR_NAME_.14, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* bitcast (void (%0*, i8*, i32)* @"\01-[A prop4To:]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@OBJC_METH_VAR_NAME_.15 = private unnamed_addr constant [7 x i8] c"_prop1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_.16 = private unnamed_addr constant [2 x i8] c"i\00", section "__TEXT,__objc_methtype,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.17 = private unnamed_addr constant [7 x i8] c"_prop2\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.18 = private unnamed_addr constant [7 x i8] c"_prop3\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.19 = private unnamed_addr constant [7 x i8] c"_prop4\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_INSTANCE_VARIABLES_A" = private global { i32, i32, [4 x %struct._ivar_t] } { i32 32, i32 4, [4 x %struct._ivar_t] [%struct._ivar_t { i64* @"OBJC_IVAR_$_A._prop1", i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.15, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_METH_VAR_TYPE_.16, i32 0, i32 0), i32 2, i32 4 }, %struct._ivar_t { i64* @"OBJC_IVAR_$_A._prop2", i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.17, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_METH_VAR_TYPE_.16, i32 0, i32 0), i32 2, i32 4 }, %struct._ivar_t { i64* @"OBJC_IVAR_$_A._prop3", i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.18, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_METH_VAR_TYPE_.16, i32 0, i32 0), i32 2, i32 4 }, %struct._ivar_t { i64* @"OBJC_IVAR_$_A._prop4", i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.19, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_METH_VAR_TYPE_.16, i32 0, i32 0), i32 2, i32 4 }] }, section "__DATA, __objc_const", align 8
+@OBJC_PROP_NAME_ATTR_.20 = private unnamed_addr constant [6 x i8] c"prop1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.21 = private unnamed_addr constant [11 x i8] c"Ti,V_prop1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.22 = private unnamed_addr constant [6 x i8] c"prop2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.23 = private unnamed_addr constant [13 x i8] c"Ti,R,V_prop2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.24 = private unnamed_addr constant [6 x i8] c"prop3\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.25 = private unnamed_addr constant [20 x i8] c"Ti,GisProp3,V_prop3\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.26 = private unnamed_addr constant [6 x i8] c"prop4\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.27 = private unnamed_addr constant [21 x i8] c"Ti,Sprop4To:,V_prop4\00", section "__TEXT,__cstring,cstring_literals", align 1
+@"\01l_OBJC_$_PROP_LIST_A" = private global { i32, i32, [4 x %struct._prop_t] } { i32 16, i32 4, [4 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.20, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_PROP_NAME_ATTR_.21, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.22, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_PROP_NAME_ATTR_.23, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.24, i32 0, i32 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @OBJC_PROP_NAME_ATTR_.25, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.26, i32 0, i32 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @OBJC_PROP_NAME_ATTR_.27, i32 0, i32 0) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_CLASS_RO_$_A" = private global %struct._class_ro_t { i32 2, i32 0, i32 16, i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [9 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_A" to %struct.__method_list_t*), %struct._objc_protocol_list* null, %struct._ivar_list_t* bitcast ({ i32, i32, [4 x %struct._ivar_t] }* @"\01l_OBJC_$_INSTANCE_VARIABLES_A" to %struct._ivar_list_t*), i8* null, %struct._prop_list_t* bitcast ({ i32, i32, [4 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A" to %struct._prop_list_t*) }, section "__DATA, __objc_const", align 8
+@OBJC_CLASS_NAME_.28 = private unnamed_addr constant [2 x i8] c"B\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@"\01l_OBJC_METACLASS_RO_$_B" = private global %struct._class_ro_t { i32 1, i32 40, i32 40, i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.28, i32 0, i32 0), %struct.__method_list_t* null, %struct._objc_protocol_list* null, %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA, __objc_const", align 8
+@"OBJC_METACLASS_$_B" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_A", %struct._class_t* @"OBJC_METACLASS_$_A", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_METACLASS_RO_$_B" }, section "__DATA, __objc_data", align 8
+@OBJC_METH_VAR_NAME_.29 = private unnamed_addr constant [7 x i8] c"method\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_INSTANCE_METHODS_B" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.29, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%1*, i8*)* @"\01-[B method]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_CLASS_RO_$_B" = private global %struct._class_ro_t { i32 0, i32 16, i32 16, i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.28, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_B" to %struct.__method_list_t*), %struct._objc_protocol_list* null, %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA, __objc_const", align 8
+@"OBJC_CLASS_$_B" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_B", %struct._class_t* @"OBJC_CLASS_$_A", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_CLASS_RO_$_B" }, section "__DATA, __objc_data", align 8
+@OBJC_METH_VAR_NAME_.30 = private unnamed_addr constant [9 x i8] c"external\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_SELECTOR_REFERENCES_.31 = private externally_initialized global i8* getelementptr inbounds ([9 x i8], [9 x i8]* @OBJC_METH_VAR_NAME_.30, i64 0, i64 0), section "__DATA,__objc_selrefs,literal_pointers,no_dead_strip", align 8
+@OBJC_CLASS_NAME_.32 = private unnamed_addr constant [2 x i8] c"C\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.33 = private unnamed_addr constant [11 x i8] c"catMethod1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.34 = private unnamed_addr constant [12 x i8] c"catMethod3:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_TYPE_.35 = private unnamed_addr constant [11 x i8] c"v24@0:8@16\00", section "__TEXT,__objc_methtype,cstring_literals", align 1
+@"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C" = private global { i32, i32, [2 x %struct._objc_method] } { i32 24, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.33, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%0*, i8*)* @"\01-[A(C) catMethod1]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([12 x i8], [12 x i8]* @OBJC_METH_VAR_NAME_.34, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.35, i32 0, i32 0), i8* bitcast (void (%0*, i8*, %2*)* @"\01-[A(C) catMethod3:]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@OBJC_METH_VAR_NAME_.36 = private unnamed_addr constant [11 x i8] c"catMethod2\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_CATEGORY_CLASS_METHODS_A_$_C" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.36, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (i8*, i8*)* @"\01+[A(C) catMethod2]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@OBJC_PROP_NAME_ATTR_.37 = private unnamed_addr constant [4 x i8] c"cp1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.38 = private unnamed_addr constant [4 x i8] c"cp2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@"\01l_OBJC_$_PROP_LIST_A_$_C" = private global { i32, i32, [2 x %struct._prop_t] } { i32 16, i32 2, [2 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.37, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.6, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.38, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.6, i32 0, i32 0) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_$_CATEGORY_A_$_C" = private global %struct._category_t { i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.32, i32 0, i32 0), %struct._class_t* @"OBJC_CLASS_$_A", %struct.__method_list_t* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C" to %struct.__method_list_t*), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_CLASS_METHODS_A_$_C" to %struct.__method_list_t*), %struct._objc_protocol_list* null, %struct._prop_list_t* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A_$_C" to %struct._prop_list_t*), %struct._prop_list_t* null, i32 64 }, section "__DATA, __objc_const", align 8
+@OBJC_CLASS_NAME_.39 = private unnamed_addr constant [3 x i8] c"C1\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.40 = private unnamed_addr constant [11 x i8] c"catMethod3\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C1" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.40, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%0*, i8*)* @"\01-[A(C1) catMethod3]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_$_CATEGORY_A_$_C1" = private global %struct._category_t { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.39, i32 0, i32 0), %struct._class_t* @"OBJC_CLASS_$_A", %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C1" to %struct.__method_list_t*), %struct.__method_list_t* null, %struct._objc_protocol_list* null, %struct._prop_list_t* null, %struct._prop_list_t* null, i32 64 }, section "__DATA, __objc_const", align 8
+@OBJC_CLASS_NAME_.41 = private unnamed_addr constant [3 x i8] c"PA\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.42 = private unnamed_addr constant [13 x i8] c"protoMethod3\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_CLASS_METHODS_PA" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.42, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (i8*, i8*)* @"\01+[PA protoMethod3]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@OBJC_CLASS_NAME_.43 = private unnamed_addr constant [2 x i8] c"P\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.44 = private unnamed_addr constant [13 x i8] c"protoMethod1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.45 = private unnamed_addr constant [14 x i8] c"protoMethod2:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.46 = private unnamed_addr constant [4 x i8] c"pp1\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.47 = private unnamed_addr constant [8 x i8] c"setPp1:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.48 = private unnamed_addr constant [4 x i8] c"pp2\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.49 = private unnamed_addr constant [8 x i8] c"setPp2:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P" = private global { i32, i32, [6 x %struct._objc_method] } { i32 24, i32 6, [6 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.44, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.45, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.35, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.46, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.47, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.48, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.49, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* null }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_P" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.42, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* null }] }, section "__DATA, __objc_const", align 8
+@OBJC_METH_VAR_NAME_.50 = private unnamed_addr constant [13 x i8] c"protoMethod4\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.51 = private unnamed_addr constant [14 x i8] c"protoMethod5:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_P" = private global { i32, i32, [2 x %struct._objc_method] } { i32 24, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.50, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* null }, %struct._objc_method { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.51, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.35, i32 0, i32 0), i8* null }] }, section "__DATA, __objc_const", align 8
+@OBJC_METH_VAR_NAME_.52 = private unnamed_addr constant [13 x i8] c"protoMethod6\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_P" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.52, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* null }] }, section "__DATA, __objc_const", align 8
+@OBJC_PROP_NAME_ATTR_.53 = private unnamed_addr constant [4 x i8] c"pp1\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.54 = private unnamed_addr constant [3 x i8] c"Ti\00", section "__TEXT,__cstring,cstring_literals", align 1
+@OBJC_PROP_NAME_ATTR_.55 = private unnamed_addr constant [4 x i8] c"pp2\00", section "__TEXT,__cstring,cstring_literals", align 1
+@"\01l_OBJC_$_PROP_LIST_P" = private global { i32, i32, [2 x %struct._prop_t] } { i32 16, i32 2, [2 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.53, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_PROP_NAME_ATTR_.54, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.55, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_PROP_NAME_ATTR_.54, i32 0, i32 0) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P" = private global [10 x i8*] [i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.35, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.35, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0)], section "__DATA, __objc_const", align 8
+@"\01l_OBJC_PROTOCOL_$_P" = weak hidden global %struct._protocol_t { i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.43, i32 0, i32 0), %struct._objc_protocol_list* null, %struct.__method_list_t* bitcast ({ i32, i32, [6 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P" to %struct.__method_list_t*), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_P" to %struct.__method_list_t*), %struct.__method_list_t* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_P" to %struct.__method_list_t*), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_P" to %struct.__method_list_t*), %struct._prop_list_t* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_P" to %struct._prop_list_t*), i32 96, i32 0, i8** getelementptr inbounds ([10 x i8*], [10 x i8*]* @"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P", i32 0, i32 0), i8* null, %struct._prop_list_t* null }, align 8
+@"\01l_OBJC_LABEL_PROTOCOL_$_P" = weak hidden global %struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P", section "__DATA,__objc_protolist,coalesced,no_dead_strip", align 8
+@"\01l_OBJC_CLASS_PROTOCOLS_$_PA" = private global { i64, [2 x %struct._protocol_t*] } { i64 1, [2 x %struct._protocol_t*] [%struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P", %struct._protocol_t* null] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_METACLASS_RO_$_PA" = private global %struct._class_ro_t { i32 1, i32 40, i32 40, i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.41, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CLASS_METHODS_PA" to %struct.__method_list_t*), %struct._objc_protocol_list* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PA" to %struct._objc_protocol_list*), %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA, __objc_const", align 8
+@"OBJC_METACLASS_$_PA" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_A", %struct._class_t* @"OBJC_METACLASS_$_A", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_METACLASS_RO_$_PA" }, section "__DATA, __objc_data", align 8
+@"\01l_OBJC_$_INSTANCE_METHODS_PA" = private global { i32, i32, [2 x %struct._objc_method] } { i32 24, i32 2, [2 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.44, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%3*, i8*)* @"\01-[PA protoMethod1]" to i8*) }, %struct._objc_method { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.45, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.35, i32 0, i32 0), i8* bitcast (void (%3*, i8*, i8*)* @"\01-[PA protoMethod2:]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_$_PROP_LIST_PA" = private global { i32, i32, [2 x %struct._prop_t] } { i32 16, i32 2, [2 x %struct._prop_t] [%struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.53, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.6, i32 0, i32 0) }, %struct._prop_t { i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.55, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.6, i32 0, i32 0) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_CLASS_RO_$_PA" = private global %struct._class_ro_t { i32 0, i32 16, i32 16, i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.41, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_PA" to %struct.__method_list_t*), %struct._objc_protocol_list* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PA" to %struct._objc_protocol_list*), %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_PA" to %struct._prop_list_t*) }, section "__DATA, __objc_const", align 8
+@"OBJC_CLASS_$_PA" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_PA", %struct._class_t* @"OBJC_CLASS_$_A", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_CLASS_RO_$_PA" }, section "__DATA, __objc_data", align 8
+@"OBJC_METACLASS_$_E" = external global %struct._class_t
+@OBJC_CLASS_NAME_.56 = private unnamed_addr constant [3 x i8] c"PB\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_CLASS_NAME_.57 = private unnamed_addr constant [3 x i8] c"P2\00", section "__TEXT,__objc_classname,cstring_literals", align 1
+@OBJC_METH_VAR_NAME_.58 = private unnamed_addr constant [13 x i8] c"protoMethod7\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+@"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P2" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.58, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* null }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P2" = private global [1 x i8*] [i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0)], section "__DATA, __objc_const", align 8
+@"\01l_OBJC_PROTOCOL_$_P2" = weak hidden global %struct._protocol_t { i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.57, i32 0, i32 0), %struct._objc_protocol_list* null, %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P2" to %struct.__method_list_t*), %struct.__method_list_t* null, %struct.__method_list_t* null, %struct.__method_list_t* null, %struct._prop_list_t* null, i32 96, i32 0, i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P2", i32 0, i32 0), i8* null, %struct._prop_list_t* null }, align 8
+@"\01l_OBJC_LABEL_PROTOCOL_$_P2" = weak hidden global %struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P2", section "__DATA,__objc_protolist,coalesced,no_dead_strip", align 8
+@"\01l_OBJC_CLASS_PROTOCOLS_$_PB" = private global { i64, [2 x %struct._protocol_t*] } { i64 1, [2 x %struct._protocol_t*] [%struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P2", %struct._protocol_t* null] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_METACLASS_RO_$_PB" = private global %struct._class_ro_t { i32 1, i32 40, i32 40, i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.56, i32 0, i32 0), %struct.__method_list_t* null, %struct._objc_protocol_list* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PB" to %struct._objc_protocol_list*), %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA, __objc_const", align 8
+@"OBJC_METACLASS_$_PB" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_E", %struct._class_t* @"OBJC_METACLASS_$_E", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_METACLASS_RO_$_PB" }, section "__DATA, __objc_data", align 8
+@"OBJC_CLASS_$_E" = external global %struct._class_t
+@"\01l_OBJC_$_INSTANCE_METHODS_PB" = private global { i32, i32, [1 x %struct._objc_method] } { i32 24, i32 1, [1 x %struct._objc_method] [%struct._objc_method { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.58, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* bitcast (void (%4*, i8*)* @"\01-[PB protoMethod7]" to i8*) }] }, section "__DATA, __objc_const", align 8
+@"\01l_OBJC_CLASS_RO_$_PB" = private global %struct._class_ro_t { i32 0, i32 0, i32 0, i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.56, i32 0, i32 0), %struct.__method_list_t* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_PB" to %struct.__method_list_t*), %struct._objc_protocol_list* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PB" to %struct._objc_protocol_list*), %struct._ivar_list_t* null, i8* null, %struct._prop_list_t* null }, section "__DATA, __objc_const", align 8
+@"OBJC_CLASS_$_PB" = global %struct._class_t { %struct._class_t* @"OBJC_METACLASS_$_PB", %struct._class_t* @"OBJC_CLASS_$_E", %struct._objc_cache* @_objc_empty_cache, i8* (i8*, i8*)** null, %struct._class_ro_t* @"\01l_OBJC_CLASS_RO_$_PB" }, section "__DATA, __objc_data", align 8
+@"OBJC_LABEL_CLASS_$" = private global [4 x i8*] [i8* bitcast (%struct._class_t* @"OBJC_CLASS_$_A" to i8*), i8* bitcast (%struct._class_t* @"OBJC_CLASS_$_B" to i8*), i8* bitcast (%struct._class_t* @"OBJC_CLASS_$_PA" to i8*), i8* bitcast (%struct._class_t* @"OBJC_CLASS_$_PB" to i8*)], section "__DATA,__objc_classlist,regular,no_dead_strip", align 8
+@"OBJC_LABEL_CATEGORY_$" = private global [2 x i8*] [i8* bitcast (%struct._category_t* @"\01l_OBJC_$_CATEGORY_A_$_C" to i8*), i8* bitcast (%struct._category_t* @"\01l_OBJC_$_CATEGORY_A_$_C1" to i8*)], section "__DATA,__objc_catlist,regular,no_dead_strip", align 8
[e-mail] = appending global [95 x i8*] [i8* bitcast (%struct._category_t* @"\01l_OBJC_$_CATEGORY_A_$_C" to i8*), i8* bitcast (%struct._category_t* @"\01l_OBJC_$_CATEGORY_A_$_C1" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_CLASS_METHODS_A_$_C" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_A_$_C1" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_CLASS_METHODS_A" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_CLASS_METHODS_PA" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._prop_t] }* @"\01l_OBJC_$_CLASS_PROP_LIST_A" to i8*), i8* bitcast ({ i32, i32, [9 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_A" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_B" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_PA" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_INSTANCE_METHODS_PB" to i8*), i8* bitcast ({ i32, i32, [4 x %struct._ivar_t] }* @"\01l_OBJC_$_INSTANCE_VARIABLES_A" to i8*), i8* bitcast ({ i32, i32, [4 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_A_$_C" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_P" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._prop_t] }* @"\01l_OBJC_$_PROP_LIST_PA" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_P" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_CLASS_METHODS_P" to i8*), i8* bitcast ({ i32, i32, [2 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_P" to i8*), i8* bitcast ({ i32, i32, [6 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P" to i8*), i8* bitcast ({ i32, i32, [1 x %struct._objc_method] }* @"\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_P2" to i8*), i8* bitcast ([10 x i8*]* @"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P" to i8*), i8* bitcast ([1 x i8*]* @"\01l_OBJC_$_PROTOCOL_METHOD_TYPES_P2" to i8*), i8* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PA" to i8*), i8* bitcast ({ i64, [2 x %struct._protocol_t*] }* @"\01l_OBJC_CLASS_PROTOCOLS_$_PB" to i8*), i8* bitcast (%struct._protocol_t** @"\01l_OBJC_LABEL_PROTOCOL_$_P" to i8*), i8* bitcast (%struct._protocol_t** @"\01l_OBJC_LABEL_PROTOCOL_$_P2" to i8*), i8* bitcast (%struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P" to i8*), i8* bitcast (%struct._protocol_t* @"\01l_OBJC_PROTOCOL_$_P2" to i8*), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.28, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.32, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.39, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.41, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_CLASS_NAME_.43, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.56, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_CLASS_NAME_.57, i32 0, i32 0), i8* bitcast ([2 x i8*]* @"OBJC_LABEL_CATEGORY_$" to i8*), i8* bitcast ([4 x i8*]* @"OBJC_LABEL_CLASS_$" to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.1, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.10, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.11, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_NAME_.12, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.13, i32 0, i32 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @OBJC_METH_VAR_NAME_.14, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.15, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.17, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.18, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.19, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.29, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_METH_VAR_NAME_.3, i32 0, i32 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @OBJC_METH_VAR_NAME_.30, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.33, i32 0, i32 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @OBJC_METH_VAR_NAME_.34, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.36, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.4, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_NAME_.40, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.42, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.44, i32 0, i32 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.45, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.46, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.47, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_METH_VAR_NAME_.48, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_NAME_.49, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.50, i32 0, i32 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @OBJC_METH_VAR_NAME_.51, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.52, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_METH_VAR_NAME_.58, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @OBJC_METH_VAR_NAME_.7, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @OBJC_METH_VAR_NAME_.9, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @OBJC_METH_VAR_TYPE_.16, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.35, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_METH_VAR_TYPE_.5, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @OBJC_METH_VAR_TYPE_.8, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.20, i32 0, i32 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @OBJC_PROP_NAME_ATTR_.21, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.22, i32 0, i32 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @OBJC_PROP_NAME_ATTR_.23, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.24, i32 0, i32 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @OBJC_PROP_NAME_ATTR_.25, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @OBJC_PROP_NAME_ATTR_.26, i32 0, i32 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @OBJC_PROP_NAME_ATTR_.27, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.37, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.38, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.53, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @OBJC_PROP_NAME_ATTR_.54, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @OBJC_PROP_NAME_ATTR_.55, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @OBJC_PROP_NAME_ATTR_.6, i32 0, i32 0), i8* bitcast (i8** @OBJC_SELECTOR_REFERENCES_ to i8*), i8* bitcast (i8** @OBJC_SELECTOR_REFERENCES_.2 to i8*), i8* bitcast (i8** @OBJC_SELECTOR_REFERENCES_.31 to i8*)], section "llvm.metadata"
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[A meth1]"(%0* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: optsize ssp uwtable
+define internal void @"\01-[A meth2:]"(%0*, i8* nocapture readnone, i32) #1 {
+  %4 = load i8*, i8** @OBJC_SELECTOR_REFERENCES_, align 8, !invariant.load !8
+  %5 = bitcast %0* %0 to i8*
+  tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*)*)(i8* %5, i8* %4) #5
+  %6 = load i8*, i8** @OBJC_SELECTOR_REFERENCES_.2, align 8, !invariant.load !8
+  %7 = tail call i32 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i32 (i8*, i8*)*)(i8* %5, i8* %6) #5
+  ret void
+}
+
+; Function Attrs: nonlazybind
+declare i8* @objc_msgSend(i8*, i8*, ...) local_unnamed_addr #2
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01+[A meth3]"(i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01+[A meth4:]"(i8* nocapture, i8* nocapture, i32) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readonly ssp uwtable
+define internal i32 @"\01-[A prop1]"(%0* nocapture readonly, i8* nocapture readnone) #3 {
+  %3 = load i64, i64* @"OBJC_IVAR_$_A._prop1", align 8, !invariant.load !8
+  %4 = bitcast %0* %0 to i8*
+  %5 = getelementptr inbounds i8, i8* %4, i64 %3
+  %6 = bitcast i8* %5 to i32*
+  %7 = load atomic i32, i32* %6 unordered, align 4
+  ret i32 %7
+}
+
+; Function Attrs: norecurse nounwind optsize ssp uwtable
+define internal void @"\01-[A setProp1:]"(%0* nocapture, i8* nocapture readnone, i32) #4 {
+  %4 = load i64, i64* @"OBJC_IVAR_$_A._prop1", align 8, !invariant.load !8
+  %5 = bitcast %0* %0 to i8*
+  %6 = getelementptr inbounds i8, i8* %5, i64 %4
+  %7 = bitcast i8* %6 to i32*
+  store atomic i32 %2, i32* %7 unordered, align 4
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readonly ssp uwtable
+define internal i32 @"\01-[A prop2]"(%0* nocapture readonly, i8* nocapture readnone) #3 {
+  %3 = load i64, i64* @"OBJC_IVAR_$_A._prop2", align 8, !invariant.load !8
+  %4 = bitcast %0* %0 to i8*
+  %5 = getelementptr inbounds i8, i8* %4, i64 %3
+  %6 = bitcast i8* %5 to i32*
+  %7 = load atomic i32, i32* %6 unordered, align 4
+  ret i32 %7
+}
+
+; Function Attrs: norecurse nounwind optsize readonly ssp uwtable
+define internal i32 @"\01-[A isProp3]"(%0* nocapture readonly, i8* nocapture readnone) #3 {
+  %3 = load i64, i64* @"OBJC_IVAR_$_A._prop3", align 8, !invariant.load !8
+  %4 = bitcast %0* %0 to i8*
+  %5 = getelementptr inbounds i8, i8* %4, i64 %3
+  %6 = bitcast i8* %5 to i32*
+  %7 = load atomic i32, i32* %6 unordered, align 4
+  ret i32 %7
+}
+
+; Function Attrs: norecurse nounwind optsize ssp uwtable
+define internal void @"\01-[A setProp3:]"(%0* nocapture, i8* nocapture readnone, i32) #4 {
+  %4 = load i64, i64* @"OBJC_IVAR_$_A._prop3", align 8, !invariant.load !8
+  %5 = bitcast %0* %0 to i8*
+  %6 = getelementptr inbounds i8, i8* %5, i64 %4
+  %7 = bitcast i8* %6 to i32*
+  store atomic i32 %2, i32* %7 unordered, align 4
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readonly ssp uwtable
+define internal i32 @"\01-[A prop4]"(%0* nocapture readonly, i8* nocapture readnone) #3 {
+  %3 = load i64, i64* @"OBJC_IVAR_$_A._prop4", align 8, !invariant.load !8
+  %4 = bitcast %0* %0 to i8*
+  %5 = getelementptr inbounds i8, i8* %4, i64 %3
+  %6 = bitcast i8* %5 to i32*
+  %7 = load atomic i32, i32* %6 unordered, align 4
+  ret i32 %7
+}
+
+; Function Attrs: norecurse nounwind optsize ssp uwtable
+define internal void @"\01-[A prop4To:]"(%0* nocapture, i8* nocapture readnone, i32) #4 {
+  %4 = load i64, i64* @"OBJC_IVAR_$_A._prop4", align 8, !invariant.load !8
+  %5 = bitcast %0* %0 to i8*
+  %6 = getelementptr inbounds i8, i8* %5, i64 %4
+  %7 = bitcast i8* %6 to i32*
+  store atomic i32 %2, i32* %7 unordered, align 4
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[B method]"(%1* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[A(C) catMethod1]"(%0* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01+[A(C) catMethod2]"(i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: optsize ssp uwtable
+define internal void @"\01-[A(C) catMethod3:]"(%0* nocapture readnone, i8* nocapture readnone, %2*) #1 {
+  %4 = load i8*, i8** @OBJC_SELECTOR_REFERENCES_.31, align 8, !invariant.load !8
+  %5 = bitcast %2* %2 to i8*
+  tail call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*)*)(i8* %5, i8* %4) #5
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[A(C1) catMethod3]"(%0* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[PA protoMethod1]"(%3* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[PA protoMethod2:]"(%3* nocapture, i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01+[PA protoMethod3]"(i8* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define internal void @"\01-[PB protoMethod7]"(%4* nocapture, i8* nocapture) #0 {
+  ret void
+}
+
+; Function Attrs: norecurse nounwind optsize readnone ssp uwtable
+define i32 @main() local_unnamed_addr #0 {
+  ret i32 0
+}
+
+attributes #0 = { norecurse nounwind optsize readnone ssp uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { optsize ssp uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #2 = { nonlazybind }
+attributes #3 = { norecurse nounwind optsize readonly ssp uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #4 = { norecurse nounwind optsize ssp uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="penryn" "target-features"="+cx16,+fxsr,+mmx,+sahf,+sse,+sse2,+sse3,+sse4.1,+ssse3,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #5 = { optsize }
+
+!llvm.module.flags = !{!0, !1, !2, !3, !4, !5, !6}
+!llvm.ident = !{!7}
+
+!0 = !{i32 1, !"Objective-C Version", i32 2}
+!1 = !{i32 1, !"Objective-C Image Info Version", i32 0}
+!2 = !{i32 1, !"Objective-C Image Info Section", !"__DATA,__objc_imageinfo,regular,no_dead_strip"}
+!3 = !{i32 4, !"Objective-C Garbage Collection", i32 0}
+!4 = !{i32 1, !"Objective-C Class Properties", i32 64}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{i32 7, !"PIC Level", i32 2}
+!7 = !{!"Apple LLVM version 10.0.0 (clang-1000.11.45.1)"}
+!8 = !{}

llvm/test/lit.cfg.py

 
 # FIXME: Why do we have both `lli` and `%lli` that do slightly different things?
 tools.extend([
     'dsymutil', 'lli', 'lli-child-target', 'llvm-ar', 'llvm-as',
     'llvm-bcanalyzer', 'llvm-config', 'llvm-cov', 'llvm-cxxdump', 'llvm-cvtres',
     'llvm-diff', 'llvm-dis', 'llvm-dwarfdump', 'llvm-exegesis', 'llvm-extract',
     'llvm-isel-fuzzer', 'llvm-jitlink', 'llvm-opt-fuzzer', 'llvm-lib',
     'llvm-link', 'llvm-lto', 'llvm-lto2', 'llvm-mc', 'llvm-mca',
-    'llvm-modextract', 'llvm-nm', 'llvm-objcopy', 'llvm-objdump',
+    'llvm-modextract', 'llvm-nm', 'llvm-objcopy', 'llvm-objdump', 'llvm-objc-metadata',
     'llvm-pdbutil', 'llvm-profdata', 'llvm-ranlib', 'llvm-rc', 'llvm-readelf',
     'llvm-readobj', 'llvm-rtdyld', 'llvm-size', 'llvm-split', 'llvm-strings',
     'llvm-strip', 'llvm-tblgen', 'llvm-undname', 'llvm-c-test', 'llvm-cxxfilt',
     'llvm-xray', 'yaml2obj', 'obj2yaml', 'yaml-bench', 'verify-uselistorder',
     'bugpoint', 'llc', 'llvm-symbolizer', 'opt', 'sancov', 'sanstats'])
 
 # The following tools are optional
 tools.extend([

llvm/tools/llvm-objc-metadata/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  Analysis
+  IRReader
+  ObjCMetadata
+  Object
+  Support
+  )
+
+add_llvm_tool(llvm-objc-metadata
+  llvm-objc-metadata.cpp
+  )

llvm/tools/llvm-objc-metadata/llvm-objc-metadata.cpp

+//===- llvm-objc-metadata.cpp - Read ObjCMetadata from Binaries -----------===//
+//
+// 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 is a tool to test ObjCMetadata library. It read the objc metadata from
+// the binaries like object file, macho binaries, etc.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/IRReader/IRReader.h"
+#include "llvm/Object/IRObjectFile.h"
+#include "llvm/Object/MachO.h"
+#include "llvm/Object/MachOUniversal.h"
+#include "llvm/Object/ObjCMetadata/ObjCBitcode.h"
+#include "llvm/Object/ObjCMetadata/ObjCMachOBinary.h"
+#include "llvm/Object/ObjCMetadata/ObjCMetadata.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+using namespace llvm::object;
+
+cl::list<std::string> InputFilenames(cl::Positional,
+                                     cl::desc("<input object files>"),
+                                     cl::ZeroOrMore);
+
+namespace llvm {
+
+LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg) {
+  errs() << "\nError reading file: " << Msg << ".\n";
+  errs().flush();
+  exit(1);
+}
+
+} // namespace llvm
+
+static void reportError(StringRef Input, std::error_code EC) {
+  if (Input == "-")
+    Input = "<stdin>";
+
+  reportError(Twine(Input) + ": " + EC.message());
+}
+
+static void reportError(Error Err) {
+  std::string ErrMsg;
+  {
+    raw_string_ostream ErrStream(ErrMsg);
+    logAllUnhandledErrors(std::move(Err), ErrStream);
+  }
+  reportError(ErrMsg);
+}
+
+static void reportError(StringRef Input, Error Err) {
+  if (Input == "-")
+    Input = "<stdin>";
+  std::string ErrMsg;
+  {
+    raw_string_ostream ErrStream(ErrMsg);
+    logAllUnhandledErrors(std::move(Err), ErrStream, Input + ": ");
+  }
+  reportError(ErrMsg);
+}
+
+static void dumpMetadata(ObjCMetaDataReader &Reader, raw_ostream &OS) {
+  OS << "Objective-C Classes:\n";
+  // Handle ObjC Classes.
+  if (auto ObjCClasses = Reader.classes()) {
+    for (auto c : *ObjCClasses) {
+      auto ObjCClass = *c;
+      if (!ObjCClass)
+        reportError(ObjCClass.takeError());
+      auto name = ObjCClass->getName();
+      if (!name)
+        reportError(name.takeError());
+
+      // Superclass.
+      if (auto superclass = ObjCClass->getSuperClassName())
+        OS << "# " << *name << " : " << *superclass << "\n";
+      else
+        reportError(superclass.takeError());
+
+      // Instance Methods.
+      if (auto instanceMethods = ObjCClass->instanceMethods()) {
+        for (auto m : *instanceMethods) {
+          if (auto mName = m.getName())
+            OS << "  instance method: " << *mName << "\n";
+          else
+            reportError(mName.takeError());
+        }
+      } else
+        reportError(instanceMethods.takeError());
+      // Class Methods.
+      if (auto classMethods = ObjCClass->classMethods()) {
+        for (auto m : *classMethods) {
+          if (auto mName = m.getName())
+            OS << "  class method: " << *mName << "\n";
+          else
+            reportError(mName.takeError());
+        }
+      } else
+        reportError(classMethods.takeError());
+      // Properties.
+      if (auto Properties = ObjCClass->properties()) {
+        for (auto m : *Properties) {
+          if (auto pName = m.getName())
+            OS << "  property: " << *pName << "\n";
+          else
+            reportError(pName.takeError());
+        }
+      } else
+        reportError(Properties.takeError());
+      // Class Properties.
+      if (auto Properties = ObjCClass->classProperties()) {
+        for (auto m : *Properties) {
+          if (auto pName = m.getName())
+            OS << "  class property: " << *pName << "\n";
+          else
+            reportError(pName.takeError());
+        }
+      } else
+        reportError(Properties.takeError());
+    }
+  } else
+    reportError(ObjCClasses.takeError());
+
+  OS << "Objective-C Protocols:\n";
+  // Handle ObjC Protocols.
+  if (auto ObjCProtocols = Reader.protocols()) {
+    for (auto p : *ObjCProtocols) {
+      auto ObjCProtocol = *p;
+      if (!ObjCProtocol)
+        reportError(ObjCProtocol.takeError());
+      auto name = ObjCProtocol->getName();
+      if (!name)
+        reportError(name.takeError());
+      OS << "# " << *name << "\n";
+      // Instance Methods.
+      if (auto instanceMethods = ObjCProtocol->instanceMethods()) {
+        for (auto m : *instanceMethods) {
+          if (auto mName = m.getName())
+            OS << "  instance method: " << *mName << "\n";
+          else
+            reportError(mName.takeError());
+        }
+      } else
+        reportError(instanceMethods.takeError());
+      if (auto instanceMethods = ObjCProtocol->optionalInstanceMethods()) {
+        for (auto m : *instanceMethods) {
+          if (auto mName = m.getName())
+            OS << "  optional instance method: " << *mName << "\n";
+          else
+            reportError(mName.takeError());
+        }
+      } else
+        reportError(instanceMethods.takeError());
+      // Class Methods.
+      if (auto classMethods = ObjCProtocol->classMethods()) {
+        for (auto m : *classMethods) {
+          if (auto mName = m.getName())
+            OS << "  class method: " << *mName << "\n";
+          else
+            reportError(mName.takeError());
+        }
+      } else
+        reportError(classMethods.takeError());
+      if (auto classMethods = ObjCProtocol->optionalClassMethods()) {
+        for (auto m : *classMethods) {
+          if (auto mName = m.getName())
+            OS << "  optional class method: " << *mName << "\n";
+          else
+            reportError(mName.takeError());
+        }
+      } else
+        reportError(classMethods.takeError());
+      // Properties.
+      if (auto Properties = ObjCProtocol->properties()) {
+        for (auto m : *Properties) {
+          if (auto pName = m.getName())
+            OS << "  property: " << *pName << "\n";
+          else
+            reportError(pName.takeError());
+        }
+      } else
+        reportError(Properties.takeError());
+    }
+  } else
+    reportError(ObjCProtocols.takeError());
+
+  OS << "Objective-C Categories:\n";
+  // Handle ObjC Categories.
+  if (auto ObjCCategories = Reader.categories()) {
+    for (auto c : *ObjCCategories) {
+      auto ObjCCategory = *c;
+      if (!ObjCCategory)
+        reportError(ObjCCategory.takeError());
+      auto name = ObjCCategory->getName();
+      if (!name)
+        reportError(name.takeError());
+      auto baseName = ObjCCategory->getBaseClassName();
+      if (!baseName)
+        reportError(baseName.takeError());
+      OS << "# " << *baseName << "(" << *name << ")\n";
+      // Instance Methods.
+      if (auto instanceMethods = ObjCCategory->instanceMethods()) {
+        for (auto m : *instanceMethods) {
+          if (auto mName = m.getName())
+            OS << "  instance method: " << *mName << "\n";
+          else
+            reportError(mName.takeError());
+        }
+      } else
+        reportError(instanceMethods.takeError());
+      // Class Methods.
+      if (auto classMethods = ObjCCategory->classMethods()) {
+        for (auto m : *classMethods) {
+          if (auto mName = m.getName())
+            OS << "  class method: " << *mName << "\n";
+          else
+            reportError(mName.takeError());
+        }
+      } else
+        reportError(classMethods.takeError());
+      // Properties.
+      if (auto Properties = ObjCCategory->properties()) {
+        for (auto m : *Properties) {
+          if (auto pName = m.getName())
+            OS << "  property: " << *pName << "\n";
+          else
+            reportError(pName.takeError());
+        }
+      } else
+        reportError(Properties.takeError());
+    }
+  } else
+    reportError(ObjCCategories.takeError());
+}
+
+static void dumpMachOObject(MachOObjectFile *Object, raw_ostream &OS) {
+  Error Err = Error::success();
+  MachOMetadata Reader(Object, Err);
+  if (Err)
+    reportError(Object->getFileName(), std::move(Err));
+
+  dumpMetadata(Reader, OS);
+}
+
+static void dumpMachOUniversalBinary(MachOUniversalBinary *Binary,
+                                     raw_ostream &OS) {
+  for (auto Slice : Binary->objects()) {
+    if (auto Object = Slice.getAsObjectFile())
+      dumpMachOObject(Object->get(), OS);
+    else
+      reportError(Binary->getFileName(), Object.takeError());
+  }
+}
+
+static void dumpIR(Module *M, raw_ostream &OS) {
+  BitcodeMetadata Reader(M);
+  dumpMetadata(Reader, OS);
+}
+
+static void dumpInputFile(StringRef File) {
+  // Read as LLVM IR.
+  auto MemBuf = MemoryBuffer::getFileOrSTDIN(File);
+  if (!MemBuf)
+    reportError(File, MemBuf.getError());
+
+  auto Context = make_unique<LLVMContext>();
+  SMDiagnostic Diag;
+  if (auto IR = parseIR((*MemBuf)->getMemBufferRef(), Diag, *Context))
+    dumpIR(IR.get(), outs());
+
+  else if (auto BinaryOrErr = createBinary((*MemBuf)->getMemBufferRef())) {
+    // Read as Binary.
+    auto *Binary = BinaryOrErr->get();
+
+    if (auto *UBinary = dyn_cast<MachOUniversalBinary>(Binary))
+      dumpMachOUniversalBinary(UBinary, outs());
+    else if (auto *Obj = dyn_cast<MachOObjectFile>(Binary))
+      dumpMachOObject(Obj, outs());
+    else // Unsupported file type.
+      reportError(File, object_error::invalid_file_type);
+  } else
+    reportError(File, BinaryOrErr.takeError());
+}
+
+int main(int argc, const char *argv[]) {
+  InitLLVM X(argc, argv);
+
+  cl::ParseCommandLineOptions(argc, argv, "llvm-objc-metadata reader");
+
+  // Default to stdin if no filename is specified.
+  if (InputFilenames.empty())
+    InputFilenames.push_back("-");
+
+  for_each(InputFilenames, dumpInputFile);
+
+  return 0;
+}