*** Terminating app due to uncaught exception 'NSInternalInconsistencyException', reason: '2 method override errors:
SubFoo does not implement required method -fooExt
SubFoo does not implement required method -foo'

➜  MustOverride tree
.
├── MustOverride.h
└── MustOverride.m

0 directories, 2 files

// MustOverride.h

/**
 * Include this macro inside any class or instance method that MUST be overridden
 * by its subclass(es). The app will then crash immediately on launch with an
 * assertion if the method is not overridden (even if it is never called).
 */
#define SUBCLASS_MUST_OVERRIDE __attribute__((used, section("__DATA,MustOverride" \
))) static const char *__must_override_entry__ = __func__

#import <Foundation/Foundation.h>

// WARNING: Unused variable 'var1'
static char *var1 = "kingcos.me";

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // printf("%s\n", var1);
    }
    return 0;
}

➜  MustOverride nm PATH/TO/MustOverrideDemo
0000000100008010 d __dyld_private
0000000100000000 T __mh_execute_header
0000000100003f50 T _main
                 U _objc_autoreleasePoolPop
                 U _objc_autoreleasePoolPush
                 U dyld_stub_binder

➜  MustOverride nm PATH/TO/MustOverrideDemo | grep var
0000000100008020 d _var1

#import <Foundation/Foundation.h>

static char *var1 = "kingcos.me";
__attribute__((used)) static char *var2 = "kingcos.me";
static char *var3 __attribute__((used)) = "kingcos.me" ;

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // printf("%s\n", var1);
    }
    return 0;
}

// SHELL OUTPUT:
// ➜  MustOverride nm PATH/TO/MustOverrideDemo | grep var
// 00000001000036d8 d _var2
// 00000001000036e0 d _var3

__attribute__((section("__DATA,kingcos.me"))) static const char *var4 = "kingcos.me";
__attribute__((section("__DATA,maimieng.com"))) static const char *var5 = "maimieng.com";

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        printf("%s", var4);
    }
    return 0;
}

// MustOverride.m

+ (void)load
{
    CheckOverrides();
}

// MustOverride.m

// 该类是否重写某个方法（该类是否实现某个方法）
static BOOL ClassOverridesMethod(Class cls, SEL selector)
{
    // 声明存储方法总数的变量
    unsigned int numberOfMethods;
    // 获取该类的方法列表，并设置方法总数
    Method *methods = class_copyMethodList(cls, &numberOfMethods);
    // 遍历该类的所有方法
    for (unsigned int i = 0; i < numberOfMethods; i++)
    {
        // 若有方法与参数的某个方法一致，则代表该类实现了该方法
        if (method_getName(methods[i]) == selector)
        {
            // 释放
            free(methods);
            return YES;
        }
    }
    // 释放
    free(methods);
    return NO;
}

// 获取某个类的所有子类
static NSArray *SubclassesOfClass(Class baseClass)
{
    // 声明存储第一个类的指针
    static Class *classes;
    // 声明存储类总数的变量
    static unsigned int classCount;
    // 保证类列表的获取只需一次（在一个程序中该列表应当是不变的）
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
      // 拷贝类列表
      classes = objc_copyClassList(&classCount);
    });

    // 声明存储子类的可变数组
    NSMutableArray *subclasses = [NSMutableArray array];
    // 遍历所有类
    for (unsigned int i = 0; i < classCount; i++)
    {
        // 存储当前遍历到的类
        Class cls = classes[i];
        Class superclass = cls;
        // 当父类存在时
        while (superclass)
        {
            // 如果父类与参数一致，说明 cls 是 baseClass 子类链之一
            if (superclass == baseClass)
            {
                // 存在子类数组中
                [subclasses addObject:cls];
                // 去遍历下个类
                break;
            }
            // 找上一级父类（找到 NSObject 的父类 nil 为止）
            superclass = class_getSuperclass(superclass);
        }
    }
    // 扫描完所有类，返回结果
    return subclasses;
}

// MustOverride.m

static void CheckOverrides(void)
{
    // 声明 Dl_info 结构体
    Dl_info info;
    // 获取当前函数地址处的镜像信息并保存在 info 中
    dladdr((const void *)&CheckOverrides, &info);

    // 获取 Mach-O 头（基地址）
    const MustOverrideValue mach_header = (MustOverrideValue)info.dli_fbase;
    // 获取 Mach-O 中相应的节信息
    const MustOverrideSection *section = GetSectByNameFromHeader((void *)mach_header, "__DATA", "MustOverride");
    // 如果未获取到则返回
    if (section == NULL) return;

    // 声明存储错误信息的可变数组
    NSMutableArray *failures = [NSMutableArray array];
    // 从 section->offset 偏移开始，每次循环跨越指向字符数组指针大小的范围，最终不超过偏移地址与节大小之和，即可遍历节中存储的信息
    for (MustOverrideValue addr = section->offset; addr < section->offset + section->size; addr += sizeof(const char **))
    {
        // 取存储的 __func__ 信息并转换为 NSString，eg: @"-[Foo(Ext) fooExt]"
        NSString *entry = @(*(const char **)(mach_header + addr));
        // 分割方法名，eg: [@"Foo(Ext)", @"fooExt"]
        NSArray *parts = [[entry substringWithRange:NSMakeRange(2, entry.length - 3)] componentsSeparatedByString:@" "];
        // 取出类名
        NSString *className = parts[0];
        // 针对分类特殊处理
        NSRange categoryRange = [className rangeOfString:@"("];
        if (categoryRange.length)
        {
            // 取出类名，eg: @"Foo"
            className = [className substringToIndex:categoryRange.location];
        }

        // 判断是否为类方法（是否以 + 开头）
        BOOL isClassMethod = [entry characterAtIndex:0] == '+';
        // 根据类名构造 Class
        Class cls = NSClassFromString(className);
        // 根据方法名构造 SEL
        SEL selector = NSSelectorFromString(parts[1]);

        // 遍历该类的所有子类
        for (Class subclass in SubclassesOfClass(cls))
        {
            // 判断类中是否有重写的方法（如果是类方法，其存储在元类的方法列表中，则传入元类对象；否则传入类对象）
            if (!ClassOverridesMethod(isClassMethod ? object_getClass(subclass) : subclass, selector))
            {
                // 添加未重写的子类和方法信息
                [failures addObject:[NSString stringWithFormat:@"%@ does not implement method %c%@ required by %@",
                                     subclass, isClassMethod ? '+' : '-', parts[1], className]];
            }
        }
    }

    // 若错误存在则触发断言，使程序终止
    NSCAssert(failures.count == 0, @"%@%@",
              failures.count > 1 ? [NSString stringWithFormat:@"%zd method override errors:\n", failures.count] : @"",
              [failures componentsJoinedByString:@"\n"]);
}

// dlfcn.h

/*
 * Structure filled in by dladdr().
 */
typedef struct dl_info {
        const char      *dli_fname;     /* Pathname of shared object */
        void            *dli_fbase;     /* Base address of shared object */
        const char      *dli_sname;     /* Name of nearest symbol */
        void            *dli_saddr;     /* Address of nearest symbol */
} Dl_info;

extern int dladdr(const void *, Dl_info *);

DLADDR(3)                BSD Library Functions Manual                DLADDR(3)

NAME
     dladdr -- find the image containing a given address

SYNOPSIS
     #include <dlfcn.h>

     int
     dladdr(const void* addr, Dl_info* info);

DESCRIPTION
     The dladdr() function queries dyld (the dynamic linker) for information
     about the image containing the address addr.  The information is returned
     in the structure specified by info.  The structure contains at least the
     following members:

     const char* dli_fname     The pathname of the shared object containing
                               the address.

     void* dli_fbase           The base address (mach_header) at which the
                               image is mapped into the address space of the
                               calling process.

     const char* dli_sname     The name of the nearest run-time symbol with a
                               value less than or equal to addr.

     void* dli_saddr           The value of the symbol returned in dli_sname.

     The dladdr() function is available only in dynamically linked programs.

ERRORS
     If an image containing addr cannot be found, dladdr() returns 0.  On suc-cess, success,
     cess, a non-zero value is returned.

     If the image containing addr is found, but no nearest symbol was found,
     the dli_sname and dli_saddr fields are set to NULL.

SEE ALSO
     dyld(3), dlopen(3)

HISTORY
     The dladdr() function first appeared in the Solaris operating system.

AUTHORS
     Mac OS X 10.3 incorporated the dlcompat package written by Jorge Acereda
     <jacereda@users.sourceforge.net> and Peter O'Gorman <ogor-
     man@users.sourceforge.net>.

     In Mac OS X 10.4, dlopen was rewritten to be a native part of dyld.

     This man page was borrowed from FreeBSD and modified.

BUGS
     This implementation is almost bug-compatible with the Solaris implementa-tion. implementation.
     tion.  The following bugs are present:

     oo   Returning 0 as an indication of failure goes against long-standing
         Unix tradition.

BSD                           September 24, 2004                           BSD

// MustOverride.m

#ifdef __LP64__
typedef uint64_t MustOverrideValue;
typedef struct section_64 MustOverrideSection;
#define GetSectByNameFromHeader getsectbynamefromheader_64
#else
typedef uint32_t MustOverrideValue;
typedef struct section MustOverrideSection;
#define GetSectByNameFromHeader getsectbynamefromheader
#endif

// mach-o/getsect.h

// 根据 Mach-O 头地址和段、节名获取节信息
// getsectbyname,  getsectdata - get the section information for the named section
extern const struct section_64 *getsectbynamefromheader_64(
    const struct mach_header_64 *mhp,
    const char *segname,
    const char *sectname);

// mach-o/loader.h

struct section_64 { /* for 64-bit architectures */
	char		sectname[16];	/* name of this section */
	char		segname[16];	/* segment this section goes in */
	uint64_t	addr;		/* memory address of this section */
	uint64_t	size;		/* size in bytes of this section */
	uint32_t	offset;		/* file offset of this section */
	uint32_t	align;		/* section alignment (power of 2) */
	uint32_t	reloff;		/* file offset of relocation entries */
	uint32_t	nreloc;		/* number of relocation entries */
	uint32_t	flags;		/* flags (section type and attributes)*/
	uint32_t	reserved1;	/* reserved (for offset or index) */
	uint32_t	reserved2;	/* reserved (for count or sizeof) */
	uint32_t	reserved3;	/* reserved */
};

#define A "aaa\n"
#define B "bbb\n"
#define C "ccc\n"

#define AB "ab\n"
#define AC "ac\n"
#define ABC "abc\n"

#define CONCAT_MACRO_1(X, Y) X##Y
#define CONCAT_MACRO_2(X, Y) X ## Y
#define CONCAT_MACRO_3(X, Y, Z) X   ##   Y ##Z

int main(int argc, const char * argv[]) {
    printf(A);
    printf(B);
    printf(C);

    printf("%s", CONCAT_MACRO_1(A, B));
    printf("%s", CONCAT_MACRO_2(A, C));
    printf("%s", CONCAT_MACRO_3(A, B, C));

    return 0;
}

// OUTPUT:
// aaa
// bbb
// ccc
// ab
// ac
// abc

#define COUNTER_MACRO printf("%d\n", __COUNTER__);

int main(int argc, const char * argv[]) {
    COUNTER_MACRO
    COUNTER_MACRO
    COUNTER_MACRO
    COUNTER_MACRO
    COUNTER_MACRO

    return 0;
}

// OUTPUT:
// 0
// 1
// 2
// 3
// 4

// main.m

#import <Foundation/Foundation.h>

int demoVar1 asm ("someVar") = 2;
int demoVar2 = 20;

void demoFunc1(void) __asm__ ("someFunc");
void demoFunc1() {
    printf("%d\n", demoVar1);
}

void demoFunc2() {
    printf("%d\n", demoVar2);
}

int main(int argc, const char * argv[]) {
    demoFunc1();
    demoFunc2();
}

➜  ~ nm PATH/TO/BINARY | grep demo
0000000100000db0 T _demoFunc2
000000010000144c D _demoVar2

➜  ~ nm PATH/TO/BINARY | grep some
0000000100000d80 T someFunc
0000000100001448 D someVar