对于iOS开发，OC语言前端使用Clang编译器，swift语言前端使用swift编译器swiftc，这两个编译器将我们写的代码编译生成IR中间代码，后端都是通过LLVM进行优化，接着交给代码生成器生成机器语言，最终形成.o机器执行文件。
在研究Swift之前，先来探究一下Swift类结构。

一、Swift类初始化

先写一段简单的代码：

class Person {
    var age: Int = 33
    var name: String = "chen"
}

let t = LGPerson()

生成SIL(Swift intermediate language)命令：swiftc -emit-sil main.swift | xcrun swift-demangle >> ./main.sil && open main.sil
xcrun swift-demangle用于还原变量，下文未用。

class Person {
  @_hasStorage @_hasInitialValue var age: Int { get set }
  @_hasStorage @_hasInitialValue var name: String { get set }
  @objc deinit
  init()
}

@_hasStorage @_hasInitialValue let t: Person { get }

// t
sil_global hidden [let] @$s4main1tAA6PersonCvp : $Person

// main
sil @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 {
bb0(%0 : $Int32, %1 : $UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>):
  alloc_global @$s4main1tAA6PersonCvp             // id: %2
  %3 = global_addr @$s4main1tAA6PersonCvp : $*Person // user: %7
  %4 = metatype $@thick Person.Type               // user: %6
  // function_ref Person.__allocating_init()
  %5 = function_ref @$s4main6PersonCACycfC : $@convention(method) (@thick Person.Type) -> @owned Person // user: %6
  %6 = apply %5(%4) : $@convention(method) (@thick Person.Type) -> @owned Person // user: %7
  store %6 to %3 : $*Person                       // id: %7
  %8 = integer_literal $Builtin.Int32, 0          // user: %9
  %9 = struct $Int32 (%8 : $Builtin.Int32)        // user: %10
  return %9 : $Int32                              // id: %10
} // end sil function 'main'

1. @main 标识当前swift文件的入口函数，SIL标识符号名称以@作为前缀。
2. %0,%1...在SIL中也叫寄存器，类似代码中的常量，一旦赋值后不可修改。如果SIL中还要继续使用，就需要使用新的寄存器。

SIL代码解读：

alloc_global @$s4main1tAA6PersonCvp     ：
@$s4main1tAA6PersonCvp反混淆出来就是Person，创建全局变量Person
%3 = global_addr @$s4main1tAA6PersonCvp : $*Person    ：读取全局变量Person地址，赋值给%3
%4 = metatype $@thick Person.Type      ：读取Person的Type，赋值给%4
%5 = function_ref @$s4main6PersonCACycfC       : $@convention(method) (@thick Person.Type) -> @owned Person      ： 定义一个function_ref即函数，就是%5，这个函数入参是Person.Type
%6 = apply %5(%4) : $@convention(method) (@thick Person.Type) -> @owned Person   
    ：调用函数%5，入参就是%4，将返回结果赋给%6
store %6 to %3 : $*Person      ：将%6的结果存储到%3，%3是LGPerson的地址
%8 = integer_literal $Builtin.Int32, 0 和 %9 = struct $Int32 (%8 : $Builtin.Int32) 
     ：就是构建一个Int值
return %9 : $Int32：  最终返回值

总结一下，main函数，通过Type返回了一个全局变量Person。

实例化过程__allocating_init

// Person.__allocating_init()
sil hidden [exact_self_class] @$s4main6PersonCACycfC : $@convention(method) (@thick Person.Type) -> @owned Person {
// %0 "$metatype"
bb0(%0 : $@thick Person.Type):
  %1 = alloc_ref $Person                          // user: %3
  // function_ref Person.init()
  %2 = function_ref @$s4main6PersonCACycfc : $@convention(method) (@owned Person) -> @owned Person // user: %3
  %3 = apply %2(%1) : $@convention(method) (@owned Person) -> @owned Person // user: %4
  return %3 : $Person                             // id: %4
} // end sil function '$s4main6PersonCACycfC'

代码解读

%1 = alloc_ref $Person   ：读取Person的alloc_ref方法地址，给%1
%2 = function_ref @$s4main6PersonCACycfc : $@convention(method) (@owned Person) -> @owned Person           ： 读取Person.init()函数地址，给%2
%3 = apply %2(%1) : $@convention(method) (@owned Person) -> @owned Person // user: %4         ： 调用alloc_ref创建一个Person实例对象，给%3
return %3 : $Person       ：返回%3的实例对象

总结一下就是，调用alloc_ref、init方法，返回对象。
init方法主要用于初始化变量，和OC中是一致的。这个过程用Swift代码会更简洁：Person() == [[Perosn alloc] init]。

初始化过程，在底层是怎么实现的，通过__allocating_init断点，我们可以跟进去

swift实例对象的创建流程
__allocating_init -> swift_allocObject-> _swift_allocObject_ -> swift_slowAlloc -> malloc_zone_malloc

具体实现，参考Swift源码，最终对象会被转为HeapObject类型。

二、Swift类的结构

2.1 HeapObject结构体

HeapObject.jpg

2.2 metadata的解析

HeapMetedata —> TargetHeapMetadata —> TargetMetadata ，他们都是struct类型，TargetMetadata里面只有一个成员变量kind。
通过注释和getKind()找到如下代码：

  /// Get the metadata kind.
  MetadataKind getKind() const {
    return getEnumeratedMetadataKind(Kind);
  }


/// Try to translate the 'isa' value of a type/heap metadata into a value
/// of the MetadataKind enum.
inline MetadataKind getEnumeratedMetadataKind(uint64_t kind) {
  if (kind > LastEnumeratedMetadataKind)
    return MetadataKind::Class;
  return MetadataKind(kind);
}

getKind是调用getEnumeratedMetadataKind，而入参kind是uint64_t类型，占8字节大小，所以元数据metadata是8字节大小。
kind类型如下：

metadata的数据结构体：

struct swift_class_t: NSObject{
    void *kind;//相当于OC中的isa，kind的实际类型是unsigned long。兼容oc，swift对象转换为oc时，即为isa指针。
    void *superClass;
    void *cacheData;
    void *data;
    uint32_t flags; //4字节
    uint32_t instanceAddressOffset;//4字节
    uint32_t instanceSize;//4字节
    uint16_t instanceAlignMask;//2字节
    uint16_t reserved;//2字节
    
    uint32_t classSize;//4字节
    uint32_t classAddressOffset;//4字节
    void *description;
    ...
}

2.3 refCounts

接着我们看看refCounts，refCounts是InlineRefCounts类型，搜索InlineRefCounts

typedef RefCounts<InlineRefCountBits> InlineRefCounts;

InlineRefCounts是RefCounts类型

RefCounts.jpg

RefCounts是class类型，确切的说，refCounts是个指针，占8字节大小。

综上所述

• swift类本质是HeapObject
• HeapObject默认大小为16字节： metadata(struct)8字节和refCounts(class)8字节
  所以，上文，Person的size应该为40字节 = age(Int)占8字节 + name(String)占16字节 + HeapObject(16字节)。

验证一下

class Person {
    var age: Int = 33
    var name: String = "chen"
}

let t = Person()


print("Int32 大小: \(MemoryLayout<Int32>.size)")
print("Int64 大小: \(MemoryLayout<Int64>.size)")
print("Int 大小: \(MemoryLayout<Int>.size)")
print("Srtring 大小: \(MemoryLayout<String>.size)")

print("Person 大小: \(class_getInstanceSize(Person.self))")

打印结果是：

image.png