#ifndef _OBJC_PRIVATE_H_

#define _OBJC_PRIVATE_H_

#include "objc-config.h"

#ifdef _OBJC_OBJC_H_

#error include objc-private.h before other headers

#endif

#define OBJC_TYPES_DEFINED 1

#define OBJC_OLD_DISPATCH_PROTOTYPES 0

#include <cstddef> // for nullptr_t

#include <stdint.h>

#include <assert.h>

struct objc_class;

struct objc_object;

typedef struct objc_class *Class;

typedef struct objc_object *id;

namespace {

struct SideTable;

};

#if (!SUPPORT_NONPOINTER_ISA && !SUPPORT_PACKED_ISA && !SUPPORT_INDEXED_ISA) ||\

( SUPPORT_NONPOINTER_ISA && SUPPORT_PACKED_ISA && !SUPPORT_INDEXED_ISA) ||\

( SUPPORT_NONPOINTER_ISA && !SUPPORT_PACKED_ISA && SUPPORT_INDEXED_ISA)

// good config

#else

# error bad config

#endif

union isa_t

{

isa_t() { }

isa_t(uintptr_t value) : bits(value) { }

Class cls;

uintptr_t bits; //存放所有的数据

#if SUPPORT_PACKED_ISA

// extra_rc must be the MSB-most field (so it matches carry/overflow flags)

// nonpointer must be the LSB (fixme or get rid of it)

// shiftcls must occupy the same bits that a real class pointer would

// bits + RC_ONE is equivalent to extra_rc + 1

// RC_HALF is the high bit of extra_rc (i.e. half of its range)

// future expansion:

// uintptr_t fast_rr : 1; // no r/r overrides

// uintptr_t lock : 2; // lock for atomic property, @synch

// uintptr_t extraBytes : 1; // allocated with extra bytes

# if __arm64__

# define ISA_MASK 0x0000000ffffffff8ULL

# define ISA_MAGIC_MASK 0x000003f000000001ULL

# define ISA_MAGIC_VALUE 0x000001a000000001ULL

struct { //利用了位域技术,这个结构体纯粹就是为了增加可读性,其它没什么作用

//0:代表普通的isa指针(存储着class、Meta-class对象的内存地址) 1:优化过的isa指针,存储了更多的信息

uintptr_t nonpointer : 1;

uintptr_t has_assoc : 1; //是否设置过关联对象,若没有,释放时更快

uintptr_t has_cxx_dtor : 1; //是否有C++的析构函数(.cxx_destruct),若没有,释放时更快

//从二进制位的倒数第三位开始数，共计33位来表示Class、Meta-Class的内存地址

uintptr_t shiftcls : 33; // MACH_VM_MAX_ADDRESS 0x1000000000

uintptr_t magic : 6; //用于在调试时分辨对象是否未完成初始化

uintptr_t weakly_referenced : 1; //是否有被弱引用指向过,若没有,释放时会更快

uintptr_t deallocating : 1; //对象是否正在释放

//引用计数器是否过大无法存储在isa中,如果是1,那么引用计数器就存储在一个叫SideTable的类的属性中

uintptr_t has_sidetable_rc : 1;

uintptr_t extra_rc : 19; //里面存储的值是引用计数值减1（如果引用计数为3，则这里存储的就是2）

# define RC_ONE (1ULL<<45)

# define RC_HALF (1ULL<<18)

};

# elif __x86_64__

# define ISA_MASK 0x00007ffffffffff8ULL

# define ISA_MAGIC_MASK 0x001f800000000001ULL

# define ISA_MAGIC_VALUE 0x001d800000000001ULL

struct {

uintptr_t nonpointer : 1;

uintptr_t has_assoc : 1;

uintptr_t has_cxx_dtor : 1;

uintptr_t shiftcls : 44; // MACH_VM_MAX_ADDRESS 0x7fffffe00000

uintptr_t magic : 6;

uintptr_t weakly_referenced : 1;

uintptr_t deallocating : 1;

uintptr_t has_sidetable_rc : 1;

uintptr_t extra_rc : 8;

# define RC_ONE (1ULL<<56)

# define RC_HALF (1ULL<<7)

};

# else

# error unknown architecture for packed isa

# endif

#endif

#if SUPPORT_INDEXED_ISA

# if __ARM_ARCH_7K__ >= 2

# define ISA_INDEX_IS_NPI 1

# define ISA_INDEX_MASK 0x0001FFFC

# define ISA_INDEX_SHIFT 2

# define ISA_INDEX_BITS 15

# define ISA_INDEX_COUNT (1 << ISA_INDEX_BITS)

# define ISA_INDEX_MAGIC_MASK 0x001E0001

# define ISA_INDEX_MAGIC_VALUE 0x001C0001

struct {

uintptr_t nonpointer : 1;

uintptr_t has_assoc : 1;

uintptr_t indexcls : 15;

uintptr_t magic : 4;

uintptr_t has_cxx_dtor : 1;

uintptr_t weakly_referenced : 1;

uintptr_t deallocating : 1;

uintptr_t has_sidetable_rc : 1;

uintptr_t extra_rc : 7;

# define RC_ONE (1ULL<<25)

# define RC_HALF (1ULL<<6)

};

# else

# error unknown architecture for indexed isa

# endif

#endif

};

struct objc_object {

};

#if __OBJC2__

typedef struct method_t *Method;

typedef struct ivar_t *Ivar;

typedef struct category_t *Category;

typedef struct property_t *objc_property_t;

#else

typedef struct old_method *Method;

typedef struct old_ivar *Ivar;

typedef struct old_category *Category;

typedef struct old_property *objc_property_t;

#endif

#include "objc.h"

#include "runtime.h"

#include "objc-os.h"

#include "objc-abi.h"

#include "objc-api.h"

#include "objc-config.h"

#include "objc-internal.h"

#include "maptable.h"

#include "hashtable2.h"

#define __APPLE_API_PRIVATE

#include "objc-gdb.h"

#undef __APPLE_API_PRIVATE

#if __OBJC2__

#include "objc-runtime-new.h"

#else

#include "objc-runtime-old.h"

#endif

#include "objc-references.h"

#include "objc-initialize.h"

#include "objc-loadmethod.h"

#if SUPPORT_PREOPT && __cplusplus

#include <objc-shared-cache.h>

using objc_selopt_t = const objc_opt::objc_selopt_t;

#else

struct objc_selopt_t;

#endif

#define STRINGIFY(x) #x

#define STRINGIFY2(x) STRINGIFY(x)

__BEGIN_DECLS

struct header_info;

typedef struct header_info_rw {

} header_info_rw;

struct header_info_rw* getPreoptimizedHeaderRW(const struct header_info *const hdr);

typedef struct header_info {

} header_info;

extern header_info *FirstHeader;

extern header_info *LastHeader;

extern int HeaderCount;

extern void appendHeader(header_info *hi);

extern void removeHeader(header_info *hi);

extern objc_image_info *_getObjcImageInfo(const headerType *head, size_t *size);

extern bool _hasObjcContents(const header_info *hi);

static inline bool segnameEquals(const char *lhs, const char *rhs) {

return 0 == strncmp(lhs, rhs, 16);

}

static inline bool segnameStartsWith(const char *segname, const char *prefix) {

return 0 == strncmp(segname, prefix, strlen(prefix));

}

static inline bool sectnameEquals(const char *lhs, const char *rhs) {

return segnameEquals(lhs, rhs);

}

static inline bool sectnameStartsWith(const char *sectname, const char *prefix){

return segnameStartsWith(sectname, prefix);

}

extern void sel_init(size_t selrefCount);

extern SEL sel_registerNameNoLock(const char *str, bool copy);

extern void sel_lock(void);

extern void sel_unlock(void);

extern SEL SEL_load;

extern SEL SEL_initialize;

extern SEL SEL_resolveClassMethod;

extern SEL SEL_resolveInstanceMethod;

extern SEL SEL_cxx_construct;

extern SEL SEL_cxx_destruct;

extern SEL SEL_retain;

extern SEL SEL_release;

extern SEL SEL_autorelease;

extern SEL SEL_retainCount;

extern SEL SEL_alloc;

extern SEL SEL_allocWithZone;

extern SEL SEL_dealloc;

extern SEL SEL_copy;

extern SEL SEL_new;

extern SEL SEL_forwardInvocation;

extern SEL SEL_tryRetain;

extern SEL SEL_isDeallocating;

extern SEL SEL_retainWeakReference;

extern SEL SEL_allowsWeakReference;

extern void preopt_init(void);

extern void disableSharedCacheOptimizations(void);

extern bool isPreoptimized(void);

extern bool noMissingWeakSuperclasses(void);

extern header_info *preoptimizedHinfoForHeader(const headerType *mhdr);

extern objc_selopt_t *preoptimizedSelectors(void);

extern Protocol *getPreoptimizedProtocol(const char *name);

extern unsigned getPreoptimizedClassUnreasonableCount();

extern Class getPreoptimizedClass(const char *name);

extern Class* copyPreoptimizedClasses(const char *name, int *outCount);

extern Class _calloc_class(size_t size);

extern IMP lookUpImpOrNil(Class, SEL, id obj, bool initialize, bool cache, bool resolver);

extern IMP lookUpImpOrForward(Class, SEL, id obj, bool initialize, bool cache, bool resolver);

extern IMP lookupMethodInClassAndLoadCache(Class cls, SEL sel);

extern bool class_respondsToSelector_inst(Class cls, SEL sel, id inst);

extern bool objcMsgLogEnabled;

extern bool logMessageSend(bool isClassMethod,

const char *objectsClass,

const char *implementingClass,

SEL selector);

extern IMP _class_lookupMethodAndLoadCache3(id, SEL, Class);

#if !OBJC_OLD_DISPATCH_PROTOTYPES

extern void _objc_msgForward_impcache(void);

#else

extern id _objc_msgForward_impcache(id, SEL, ...);

#endif

extern void __objc_error(id, const char *, ...) __attribute__((format (printf, 2, 3), noreturn));

extern void _objc_inform(const char *fmt, ...) __attribute__((format (printf, 1, 2)));

extern void _objc_inform_on_crash(const char *fmt, ...) __attribute__((format (printf, 1, 2)));

extern void _objc_inform_now_and_on_crash(const char *fmt, ...) __attribute__((format (printf, 1, 2)));

extern void _objc_inform_deprecated(const char *oldname, const char *newname) __attribute__((noinline));

extern void inform_duplicate(const char *name, Class oldCls, Class cls);

extern Class _objc_getFreedObjectClass (void);

extern void *NXMapKeyCopyingInsert(NXMapTable *table, const void *key, const void *value);

extern void *NXMapKeyFreeingRemove(NXMapTable *table, const void *key);

extern unsigned _NXHashCapacity(NXHashTable *table);

extern void _NXHashRehashToCapacity(NXHashTable *table, unsigned newCapacity);

extern const char *copyPropertyAttributeString(const objc_property_attribute_t *attrs, unsigned int count);

extern objc_property_attribute_t *copyPropertyAttributeList(const char *attrs, unsigned int *outCount);

extern char *copyPropertyAttributeValue(const char *attrs, const char *name);

extern void lock_init(void);

class monitor_locker_t : nocopy_t {

};

class recursive_mutex_locker_t : nocopy_t {

};

class rwlock_reader_t : nocopy_t {

};

class rwlock_writer_t : nocopy_t {

};

struct alt_handler_list;

extern void exception_init(void);

extern void _destroyAltHandlerList(struct alt_handler_list *list);

#define OBJC_CLASS_ADDED (1<<0)

#define OBJC_CLASS_REMOVED (1<<1)

#define OBJC_CLASS_IVARS_CHANGED (1<<2)

#define OBJC_CLASS_METHODS_CHANGED (1<<3)

extern void gdb_objc_class_changed(Class cls, unsigned long changes, const char *classname)

__attribute__((noinline));

#define OPTION(var, env, help) extern bool var;

#include "objc-env.h"

#undef OPTION

extern void environ_init(void);

extern void logReplacedMethod(const char *className, SEL s, bool isMeta, const char *catName, IMP oldImp, IMP newImp);

typedef struct {

struct _objc_initializing_classes *initializingClasses; // for +initialize

struct SyncCache *syncCache; // for @synchronize

struct alt_handler_list *handlerList; // for exception alt handlers

char *printableNames[4]; // temporary demangled names for logging

// If you add new fields here, don't forget to update

// _objc_pthread_destroyspecific()

} _objc_pthread_data;

extern _objc_pthread_data *_objc_fetch_pthread_data(bool create);

extern void tls_init(void);

extern unsigned int encoding_getNumberOfArguments(const char *typedesc);

extern unsigned int encoding_getSizeOfArguments(const char *typedesc);

extern unsigned int encoding_getArgumentInfo(const char *typedesc, unsigned int arg, const char **type, int *offset);

extern void encoding_getReturnType(const char *t, char *dst, size_t dst_len);

extern char * encoding_copyReturnType(const char *t);

extern void encoding_getArgumentType(const char *t, unsigned int index, char *dst, size_t dst_len);

extern char *encoding_copyArgumentType(const char *t, unsigned int index);

extern void _destroySyncCache(struct SyncCache *cache);

extern void arr_init(void);

extern id objc_autoreleaseReturnValue(id obj);

extern IMP _imp_implementationWithBlockNoCopy(id block);

typedef struct {

uint8_t *bits;

size_t bitCount;

size_t bitsAllocated;

bool weak;

} layout_bitmap;

extern layout_bitmap layout_bitmap_create(const unsigned char *layout_string, size_t layoutStringInstanceSize, size_t instanceSize, bool weak);

extern layout_bitmap layout_bitmap_create_empty(size_t instanceSize, bool weak);

extern void layout_bitmap_free(layout_bitmap bits);

extern const unsigned char *layout_string_create(layout_bitmap bits);

extern void layout_bitmap_set_ivar(layout_bitmap bits, const char *type, size_t offset);

extern void layout_bitmap_grow(layout_bitmap *bits, size_t newCount);

extern void layout_bitmap_slide(layout_bitmap *bits, size_t oldPos, size_t newPos);

extern void layout_bitmap_slide_anywhere(layout_bitmap *bits, size_t oldPos, size_t newPos);

extern bool layout_bitmap_splat(layout_bitmap dst, layout_bitmap src,

size_t oldSrcInstanceSize);

extern bool layout_bitmap_or(layout_bitmap dst, layout_bitmap src, const char *msg);

extern bool layout_bitmap_clear(layout_bitmap dst, layout_bitmap src, const char *msg);

extern void layout_bitmap_print(layout_bitmap bits);

extern bool MultithreadedForkChild;

extern id objc_noop_imp(id self, SEL _cmd);

extern Class look_up_class(const char *aClassName, bool includeUnconnected, bool includeClassHandler);

extern "C" void map_images(unsigned count, const char * const paths[],

const struct mach_header * const mhdrs[]);

extern void map_images_nolock(unsigned count, const char * const paths[],

const struct mach_header * const mhdrs[]);

extern void load_images(const char *path, const struct mach_header *mh);

extern void unmap_image(const char *path, const struct mach_header *mh);

extern void unmap_image_nolock(const struct mach_header *mh);

extern void _read_images(header_info **hList, uint32_t hCount, int totalClasses, int unoptimizedTotalClass);

extern void _unload_image(header_info *hi);

extern const char ** _objc_copyClassNamesForImage(header_info *hi, unsigned int *outCount);

extern const header_info *_headerForClass(Class cls);

extern Class _class_remap(Class cls);

extern Class _class_getNonMetaClass(Class cls, id obj);

extern Ivar _class_getVariable(Class cls, const char *name);

extern unsigned _class_createInstancesFromZone(Class cls, size_t extraBytes, void *zone, id *results, unsigned num_requested);

extern id _objc_constructOrFree(id bytes, Class cls);

extern const char *_category_getName(Category cat);

extern const char *_category_getClassName(Category cat);

extern Class _category_getClass(Category cat);

extern IMP _category_getLoadMethod(Category cat);

extern id object_cxxConstructFromClass(id obj, Class cls);

extern void object_cxxDestruct(id obj);

extern void _class_resolveMethod(Class cls, SEL sel, id inst);

extern void fixupCopiedIvars(id newObject, id oldObject);

extern Class _class_getClassForIvar(Class cls, Ivar ivar);

#define OBJC_WARN_DEPRECATED \

do { \

static int warned = 0; \

if (!warned) { \

warned = 1; \

_objc_inform_deprecated(__FUNCTION__, NULL); \

} \

} while (0) \

__END_DECLS

#ifndef STATIC_ASSERT

# define STATIC_ASSERT(x) _STATIC_ASSERT2(x, __LINE__)

# define _STATIC_ASSERT2(x, line) _STATIC_ASSERT3(x, line)

# define _STATIC_ASSERT3(x, line) \

typedef struct { \

int _static_assert[(x) ? 0 : -1]; \

} _static_assert_ ## line __attribute__((unavailable))

#endif

#define countof(arr) (sizeof(arr) / sizeof((arr)[0]))

static __inline uint32_t _objc_strhash(const char *s) {

}

#if __cplusplus

template <typename T>

static inline T log2u(T x) {

return (x<2) ? 0 : log2u(x>>1)+1;

}

template <typename T>

static inline T exp2u(T x) {

return (1 << x);

}

template <typename T>

static T exp2m1u(T x) {

return (1 << x) - 1;

}

#endif

__attribute__((aligned(1))) typedef uintptr_t unaligned_uintptr_t;

__attribute__((aligned(1))) typedef intptr_t unaligned_intptr_t;

__attribute__((aligned(1))) typedef uint64_t unaligned_uint64_t;

__attribute__((aligned(1))) typedef int64_t unaligned_int64_t;

__attribute__((aligned(1))) typedef uint32_t unaligned_uint32_t;

__attribute__((aligned(1))) typedef int32_t unaligned_int32_t;

__attribute__((aligned(1))) typedef uint16_t unaligned_uint16_t;

__attribute__((aligned(1))) typedef int16_t unaligned_int16_t;

#if __cplusplus

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Winline-new-delete"

#include <new>

inline void* operator new(std::size_t size) throw (std::bad_alloc) { return malloc(size); }

inline void* operator new[](std::size_t size) throw (std::bad_alloc) { return malloc(size); }

inline void* operator new(std::size_t size, const std::nothrow_t&) throw() { return malloc(size); }

inline void* operator new[](std::size_t size, const std::nothrow_t&) throw() { return malloc(size); }

inline void operator delete(void* p) throw() { free(p); }

inline void operator delete[](void* p) throw() { free(p); }

inline void operator delete(void* p, const std::nothrow_t&) throw() { free(p); }

inline void operator delete[](void* p, const std::nothrow_t&) throw() { free(p); }

#pragma clang diagnostic pop

#endif

class TimeLogger {

};

template<typename T>

class StripedMap {

};

template <typename T>

class DisguisedPtr {