Mach-O的链接、装载与库

// 这段代码中包含多个符号
void myFunction(void) {           // 定义了符号 _myFunction
    NSLog(@"Hello");              // 引用了外部符号 _NSLog
}

int globalVar = 10;               // 定义了符号 _globalVar

# 常见的链接错误示例
Undefined symbols for architecture arm64:
  "_myFunction", referenced from:
      _main in main.o
ld: symbol(s) not found for architecture arm64

duplicate symbol '_globalVar' in:
    foo.o
    bar.o

# 查看文件类型
$ file /bin/ls
/bin/ls: Mach-O universal binary with 2 architectures

# 常见的Mach-O类型
MH_EXECUTE    # 可执行文件（App的主二进制）
MH_DYLIB      # 动态库（.dylib, .framework）
MH_OBJECT     # 目标文件（.o，静态库中的单元）
MH_BUNDLE     # Bundle（插件）

┌──────────────────────────┐
│           Header         │  ← 文件的"身份证"
├──────────────────────────┤
│       Load Commands      │  ← 文件的"目录"
├──────────────────────────┤
│            Data          │  ← 实际的代码和数据
└──────────────────────────┘

struct mach_header_64 {
    uint32_t      magic;         // 魔数，标识文件格式
    cpu_type_t    cputype;       // CPU类型：ARM64, X86_64
    uint32_t      filetype;      // 文件类型：可执行文件、动态库等
    uint32_t      ncmds;         // Load Commands的数量
    // ...
};

Load Commands 示例：
├── LC_SEGMENT_64 (__TEXT)      → 代码段的位置和大小
├── LC_SEGMENT_64 (__DATA)      → 数据段的位置和大小
├── LC_LOAD_DYLIB (Foundation)  → 依赖Foundation框架
├── LC_LOAD_DYLIB (UIKit)       → 依赖UIKit框架
└── LC_SYMTAB                   → 符号表的位置

Mach-O Data 区组织结构

┌─────────────────────────────────────────────────────────┐
│                     Segment（段）                        │
│  - 是内存映射的基本单位                                    │
│  - 定义内存保护属性（可读/可写/可执行）                      │
│  - 页对齐（通常 16KB）                                    │
│                                                        │
│  ┌─────────────────────────────────────────────────┐   │
│  │               Section（节）                      │   │
│  │  - 是数据组织的逻辑单位                            │   │
│  │  - 同一 Segment 内的多个 Section 共享内存属性       │   │
│  │  - 存放特定类型的数据                              │   │
│  └─────────────────────────────────────────────────┘   │
└────────────────────────────────────────────────────────┘

__TEXT Segment（可读、可执行）
│
├── __text Section      ← 编译后的机器码
├── __stubs Section     ← 动态库调用桩
├── __cstring Section   ← C字符串常量
└── __const Section     ← 常量数据

所有这些 Section 都继承 __TEXT 的权限：可读、可执行、不可写

// 以下代码都会因访问__PAGEZERO而崩溃
NSString *str = nil;
NSLog(@"%c", str[0]);      // 访问地址0x0，崩溃

int *ptr = NULL;
*ptr = 42;                  // 写入地址0x0，崩溃

// 即使偏移一定量，仍在4GB范围内
char *p = (char *)0x1000;
*p = 'a';                   // 访问地址0x1000，仍在__PAGEZERO范围内，崩溃

__TEXT Segment（可读、可执行）
├── __text           编译后的机器码（ObjC和Swift）
├── __stubs          动态库函数调用的桩代码
├── __stub_helper    辅助延迟绑定的代码
├── __cstring        C字符串常量 "Hello World"
├── __const          const修饰的常量数据
│
├── [ObjC相关]
│   ├── __objc_methname  ObjC方法名 "viewDidLoad"
│   ├── __objc_classname ObjC类名 "UIViewController"
│   └── __objc_methtype  方法类型编码 "v@:"
│
└── [Swift相关]
    ├── __swift5_typeref  Swift类型引用（mangled名称字符串）
    ├── __swift5_reflstr  Swift反射字符串（属性名、枚举case名）
    └── __swift5_entry    Swift入口点信息

__DATA_CONST（可读写→只读，启动后变为只读）
├── __got              非延迟绑定的符号指针
├── __const            运行时确定的常量
│
├── [ObjC相关]
│   ├── __objc_classlist   ObjC类列表指针
│   ├── __objc_protolist   ObjC协议列表指针
│   └── __objc_imageinfo   ObjC镜像信息
│
└── [Swift相关]
    ├── __swift5_proto     Swift协议描述符
    └── __swift5_types     Swift类型描述符（struct/class/enum元数据）

__DATA（可读写）
├── __la_symbol_ptr    延迟绑定的符号指针
├── __data             已初始化的全局/静态变量
├── __bss              未初始化的全局/静态变量
├── __common           未初始化的外部全局变量
│
├── [ObjC相关]
│   └── __objc_ivar        ObjC实例变量
│
└── [Swift相关]
    ├── __swift5_fieldmd   Swift字段元数据（属性类型和偏移）
    ├── __swift5_assocty   Swift关联类型信息
    └── __swift5_protos    Swift协议一致性记录

__DATA_DIRTY（一定会被写入的数据）
└── 运行时一定会修改的数据，单独分页以优化COW

__LINKEDIT Segment（只读）
├── 符号表 (Symbol Table)      函数、变量的名称和地址
├── 字符串表 (String Table)    符号名称的字符串
├── 间接符号表                  用于动态链接
├── 重定位信息                  Rebase/Bind需要的信息
├── 代码签名                    Code Signature
└── 函数起始地址表              用于栈回溯

__DATA段（整个段都是可读写的）
├── __got              ← 启动时写入一次，之后不变
├── __objc_classlist   ← 启动时写入一次，之后不变
├── __la_symbol_ptr    ← 运行时可能修改
└── __data             ← 运行时可能修改

问题：整个__DATA段都不能在进程间共享

__DATA_CONST（启动后变为只读）
├── __got              可以在多进程间共享
└── __objc_classlist   可以在多进程间共享

__DATA（保持可读写）
├── __la_symbol_ptr
└── __data

# 查看依赖的动态库
$ otool -L MyApp
MyApp:
    /System/Library/Frameworks/Foundation.framework/Foundation
    /System/Library/Frameworks/UIKit.framework/UIKit
    /usr/lib/libobjc.A.dylib

# 查看Load Commands
$ otool -l MyApp

# 查看符号表
$ nm -m MyApp
(undefined) external _NSLog              # 未定义，需要从Foundation导入
(__TEXT,__text) external _main           # 已定义，在代码段

# 静态库本质是.o文件的归档
$ ar -t libMyStatic.a
MyClass.o
MyHelper.o
MyUtils.o

编译时（各自从0开始）：

main.o:                    foo.o:
0x0000: _main              0x0000: _foo
0x0020: call _foo          0x0010: call _bar
        ↓ 指向0x????               ↓ 指向0x????

链接后（合并到统一地址空间）：

可执行文件:
0x1000: _main
0x1020: call _foo  → 修正为 call 0x2000
        ...
0x2000: _foo
0x2010: call _bar  → 修正为 call 0x2100
        ...
0x2100: _bar

# 1. 编译源文件为目标文件
clang -c MyClass.m -o MyClass.o

# 2. 打包为静态库
ar rcs libMyStatic.a MyClass.o MyHelper.o

# 3. 链接静态库
clang main.m -L. -lMyStatic -o main

编译时假设的基地址：0x100000000

第一次运行：实际加载地址 = 0x100000000 + 0x5000 (随机偏移)
第二次运行：实际加载地址 = 0x100000000 + 0x8000 (不同的随机偏移)

- ObjC类的方法列表指针（指向__TEXT段的方法名）
- ObjC类的父类指针（指向父类的Class结构）
- 全局变量的初始化指针（如 NSString *str = @"hello" 中的字符串地址）
- Block的函数指针（指向Block的invoke函数）
- C++虚函数表指针
- Swift类型的元数据指针

实际地址 = 编译时地址 + slide

示例：
编译时假设基地址: 0x100000000
实际加载基地址:   0x100005000  (slide = 0x5000)

某ObjC类的方法列表指针:
  编译时值: 0x100001000
  Rebase后: 0x100001000 + 0x5000 = 0x100006000

- 调用系统函数的指针（_NSLog, _objc_msgSend, _malloc, _dispatch_async）
- 引用系统类的指针（_OBJC_CLASS_$_NSObject, _OBJC_CLASS_$_UIView）
- 引用其他动态库中全局变量的指针
- Swift标准库函数的指针

1. dyld读取Mach-O中的绑定信息，获取符号名（如"_NSLog"）和目标库（如Foundation）
2. 在目标库的符号表中查找该符号的地址
3. 将找到的地址写入对应的指针位置（通常在__DATA段的__got或__la_symbol_ptr）

示例：
符号名: _NSLog
目标库: Foundation
查找结果: 0x7FFF20123456
写入位置: __DATA,__got 中的 _NSLog 条目

# 查看Rebase信息
$ xcrun dyldinfo -rebase MyApp
rebase information:
segment  section          address     type
__DATA   __objc_classlist 0x100008000 pointer
__DATA   __data           0x100008020 pointer

# 查看Bind信息
$ xcrun dyldinfo -bind MyApp
bind information:
segment  section  address        dylib       symbol
__DATA   __got    0x100008000    libSystem   _malloc
__DATA   __got    0x100008008    libobjc     _objc_msgSend

# 查看Lazy Bind信息
$ xcrun dyldinfo -lazy_bind MyApp
lazy binding information:
segment  section          address        dylib       symbol
__DATA   __la_symbol_ptr  0x100008100    Foundation  _NSLog

缓存的内容（与slide无关）：
├── 需要Rebase的指针位置列表
├── 需要Bind的符号及其目标位置
├── 依赖库的加载顺序
└── Initializer的调用顺序

不缓存的内容：
├── slide值（每次启动由ASLR随机生成）
└── 最终的指针地址值

首次启动：解析Mach-O → 分析Rebase/Bind位置 → 缓存到磁盘 → 执行Rebase/Bind
后续启动：读取缓存 → 跳过解析步骤 → 直接执行Rebase/Bind（更快）

__LINKEDIT段中的Rebase信息：
┌─────────────────────────────────────────────────┐
│ 位置1: 0x8000  │ 位置2: 0x8008  │ 位置3: 0x8010 │ ...
└─────────────────────────────────────────────────┘
        ↓               ↓               ↓
     需要Rebase      需要Rebase      需要Rebase

dyld启动时：
1. 读取__LINKEDIT中的地址列表
2. 跳转到0x8000，执行 *0x8000 += slide
3. 跳转到0x8008，执行 *0x8008 += slide
4. 跳转到0x8010，执行 *0x8010 += slide
... 重复数千次

传统方式：
__LINKEDIT: [0x8000, 0x8008, 0x8010]  ← 单独存储位置列表
__DATA:     [指针A] [指针B] [指针C]    ← 实际指针值

Chained Fixups：
__LINKEDIT: [链表起始位置: 0x8000]    ← 只需记录起点
__DATA:     [指针A|next=2] [指针B|next=2] [指针C|next=0]
                   ↓              ↓              ↓
                 +8字节         +8字节           结束

1. dyld读取链表起始位置（从__LINKEDIT的少量元数据中获取）
2. 从起始位置开始遍历：
   a. 读取当前指针值
   b. 解析bind标志：
      - bind=0: 执行Rebase，新值 = target + slide
      - bind=1: 执行Bind，新值 = 符号表[ordinal]的地址
   c. 解析next字段，跳转到下一个指针
   d. 重复直到next=0
3. 所有修正完成

dyld shared cache 位置：
/System/Library/dyld/dyld_shared_cache_arm64e（常见路径，具体文件名会随系统版本和架构变化）

包含的库：Foundation, UIKit, CoreFoundation, libobjc 等数百个系统库

#import <dlfcn.h>

// 动态加载库
void *handle = dlopen("/path/to/library.dylib", RTLD_NOW);

// 查找符号
typedef void (*FunctionType)(void);
FunctionType func = (FunctionType)dlsym(handle, "myFunction");
if (func) {
    func();  // 调用动态库中的函数
}

// 卸载库
dlclose(handle);

C语言：
  void foo()  →  _foo

Objective-C：
  +[MyClass doSomething]  →  +[MyClass doSomething]
  -[MyClass doSomething]  →  -[MyClass doSomething]

C++（需要编码参数类型以支持重载）：
  void foo(int)  →  __Z3fooi
  void foo(float)  →  __Z3foof

Swift（复杂的修饰方案，编码了模块、类型、函数签名等信息）：
  func foo()  →  $s4Main3fooyyF

// FrameworkA 中的类
@interface MyClass : NSObject  →  符号: _OBJC_CLASS_$_MyClass
@end

// FrameworkB 中的类（同名）
@interface MyClass : NSObject  →  符号: _OBJC_CLASS_$_MyClass  ← 冲突！
@end

NSObject      → Foundation框架
UIView        → UIKit框架
AFHTTPClient  → AFNetworking库
SDWebImage    → SDWebImage库

// ModuleA 中
class MyClass {}  →  符号: $s7ModuleA7MyClassC...

// ModuleB 中
class MyClass {}  →  符号: $s7ModuleB7MyClassC...  ← 不冲突

$s4Main3fooyyF
│ │    │   │││
│ │    │   ││└── F = 函数
│ │    │   │└─── y = Void返回类型
│ │    │   └──── y = 无参数
│ │    └─────── foo = 函数名（3个字符）
│ └──────────── Main = 模块名（4个字符）
└────────────── $s = Swift符号前缀

更复杂的例子：
$s4Main6PersonC4name3ageSSSi_tcfc
→ Main.Person.init(name: String, age: Int)

$ swift demangle '$s4Main3fooyyF'
$s4Main3fooyyF ---> Main.foo() -> ()

default（默认）：符号被导出，外部可见，可以被其他模块链接
hidden（隐藏）：符号不导出，仅内部可见，外部无法链接

// 显式导出（默认行为）
__attribute__((visibility("default")))
void publicFunction(void);

// 隐藏符号，不导出
__attribute__((visibility("hidden")))
void privateFunction(void);

// ObjC类也可以设置可见性
__attribute__((visibility("hidden")))
@interface InternalHelper : NSObject
@end

// 定义导出宏（通常在框架的头文件中）
#define MY_EXPORT __attribute__((visibility("default")))
#define MY_HIDDEN __attribute__((visibility("hidden")))

MY_EXPORT void publicAPI(void);
MY_HIDDEN void internalHelper(void);

Build Settings:
├── Symbols Hidden by Default = YES    ← 默认隐藏所有符号
└── 然后用 __attribute__((visibility("default"))) 显式导出需要公开的符号

public func publicAPI() {}      // 导出，外部模块可访问
internal func internalFunc() {} // 不导出，仅当前模块可访问（默认）
private func privateFunc() {}   // 不导出，仅当前文件可访问

# 查看导出的符号
$ nm -gU MyFramework.framework/MyFramework
0000000000001000 T _publicFunction      # T = 已导出的代码符号

# 查看所有符号（包括未导出的）
$ nm -a MyFramework.framework/MyFramework
0000000000001000 T _publicFunction
0000000000001100 t _privateFunction     # t = 未导出的代码符号（小写）

传统Unix（Flat Namespace）：
  所有动态库的符号在同一命名空间 → 可能冲突

Two-Level Namespace：
  符号 = 库名 + 符号名
  _NSLog@Foundation  vs  _NSLog@MyLibrary  → 不冲突

App启动时：
1. dyld 加载所有动态库（Two-Level Namespace 在这里工作）
2. ObjC Runtime 遍历所有类，注册到全局类表（以类名为 key）
   → 同名类在这里冲突，与 Two-Level Namespace 无关

MyFramework.framework/
├── MyFramework           # 库二进制（可以是动态库或静态库）
├── Headers/              # 公开头文件
│   └── MyFramework.h
├── Modules/              # 模块定义
│   └── module.modulemap
├── Info.plist            # 框架信息
└── Resources/            # 资源文件（可选）

# Podfile
platform :ios, '13.0'

target 'MyApp' do
  pod 'AFNetworking'
  pod 'SDWebImage'
end

Pods/
├── libPods-MyApp.a              ← 所有Pod合并成一个静态库
├── AFNetworking/
│   └── 源码
└── SDWebImage/
    └── 源码

# Podfile
platform :ios, '13.0'
use_frameworks!

target 'MyApp' do
  pod 'Alamofire'     # Swift库
  pod 'SDWebImage'    # ObjC库
end

Pods/
├── Alamofire.framework/         ← 每个Pod一个动态Framework
├── SDWebImage.framework/
└── Pods_MyApp.framework/        ← 伞Framework

# Podfile
platform :ios, '13.0'
use_frameworks! :linkage => :static

target 'MyApp' do
  pod 'Alamofire'
  pod 'SDWebImage'
end

Pods/
├── Alamofire.framework/         ← 静态Framework（有Module支持）
├── SDWebImage.framework/        ← 静态Framework
└── ...

# 场景：想用静态库（启动快），又需要在Swift中使用ObjC的Pod

# 方案1：use_frameworks!（动态库，启动慢）
use_frameworks!

# 方案2：use_modular_headers!（静态库 + Module支持）
use_modular_headers!

target 'MyApp' do
  pod 'AFNetworking'  # ObjC库，现在Swift可以import了
end

# 全局启用
use_modular_headers!

# 或者只对特定Pod启用
pod 'AFNetworking', :modular_headers => true

# 或者全局启用，排除特定Pod
use_modular_headers!
pod 'SomeLegacyPod', :modular_headers => false

# Fat Framework结构
$ lipo -info MyFramework.framework/MyFramework
Architectures in the fat file: armv7 arm64 x86_64 i386

# 提交前需要手动移除模拟器架构
lipo -remove x86_64 -remove i386 MyFramework -output MyFramework_device

MyFramework.xcframework/
├── Info.plist                          # 描述所有变体的元信息
├── ios-arm64/                          # iOS真机（arm64）
│   └── MyFramework.framework/
│       ├── MyFramework                 # 二进制
│       ├── Headers/
│       ├── Modules/
│       └── Info.plist
├── ios-arm64_x86_64-simulator/         # iOS模拟器（支持Intel和Apple Silicon Mac）
│   └── MyFramework.framework/
│       └── ...
├── macos-arm64_x86_64/                 # macOS（Universal Binary）
│   └── MyFramework.framework/
│       └── ...
└── watchos-arm64_32_armv7k/            # watchOS
    └── MyFramework.framework/
        └── ...

┌──────────────────────────┐
│           Header         │  ← 文件的"身份证"
├──────────────────────────┤
│       Load Commands      │  ← 文件的"目录"
├──────────────────────────┤
│            Data          │  ← 实际的代码和数据
└──────────────────────────┘

示例：__TEXT Segment（可读、可执行）
├── __text Section      ← 编译后的机器码
├── __stubs Section     ← 动态库调用桩
├── __cstring Section   ← C字符串常量
└── __const Section     ← 常量数据

所有这些Section都继承__TEXT的权限：可读、可执行、不可写

Objective-C:
  +[MyClass doSomething]  →  +[MyClass doSomething]
  -[MyClass doSomething]  →  -[MyClass doSomething]
  类符号                   →  _OBJC_CLASS_$_MyClass

Swift:
  func foo()              →  $s4Main3fooyyF
  MyModule.MyClass        →  $s8MyModule7MyClassC...

$ swift demangle '$s4Main3fooyyF'
$s4Main3fooyyF ---> Main.foo() -> ()

$ swift demangle '$s4Main6PersonC4name3ageSSSi_tcfc'
... ---> Main.Person.init(name: String, age: Int)

MyFramework.xcframework/
├── Info.plist                          # 描述所有变体的元信息
├── ios-arm64/                          # iOS真机
│   └── MyFramework.framework/
├── ios-arm64_x86_64-simulator/         # iOS模拟器（支持Intel和Apple Silicon Mac）
│   └── MyFramework.framework/
└── macos-arm64_x86_64/                 # macOS
    └── MyFramework.framework/