Swift 的 MemoryLayout 是如何工作的（1）

struct Point {
    let x: Double
    let y: Double
    let isFilled: Bool
}

func getSize() -> Int {
    return MemoryLayout<Int16>.size
}

xcrun swiftc -dump-ast file.swift  

(source_file "file.swift"
  (func_decl range=[file.swift:7:1 - line:9:1] "getSize()" interface type='() -> Int' access=internal
    (parameter_list range=[file.swift:7:13 - line:7:14])
    (result
      (type_ident
        (component id='Int' bind=Swift.(file).Int)))
    (brace_stmt range=[file.swift:7:23 - line:9:1]
      (return_stmt range=[file.swift:8:5 - line:8:32]
        (member_ref_expr type='Int' location=file.swift:8:32 range=[file.swift:8:12 - line:8:32] decl=Swift.(file).MemoryLayout.size [with (substitution_map generic_signature=<T> (substitution T -> Int16))]
          (type_expr type='MemoryLayout<Int16>.Type' location=file.swift:8:12 range=[file.swift:8:12 - line:8:30] typerepr='MemoryLayout<Int16>'))))))

xcrun swiftc -emit-silgen -O file.swift | swift demangle

sil_stage raw

import Builtin
import Swift
import SwiftShims

func getSize() -> Int

// main
sil [ossa] @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 {
bb0(%0 : $Int32, %1 : $UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>):
  %2 = integer_literal $Builtin.Int32, 0          // user: %3
  %3 = struct $Int32 (%2 : $Builtin.Int32)        // user: %4
  return %3 : $Int32                              // id: %4
} // end sil function 'main'

// getSize()
sil hidden [ossa] @file.getSize() -> Swift.Int : $@convention(thin) () -> Int {
bb0:
  // 获得 MemoryLayout<Int16>.Type 类型
  %0 = metatype $@thin MemoryLayout<Int16>.Type   // user: %2

  // 获得 静态属性 size 的 get 方法
  // function_ref static MemoryLayout.size.getter
  %1 = function_ref @static Swift.MemoryLayout.size.getter : Swift.Int : $@convention(method) <τ_0_0> (@thin MemoryLayout<τ_0_0>.Type) -> Int // user: %2

  // 调用 静态属性 size 的 get 方法，参数是 MemoryLayout<Int16>.Type，并返回一个 Int 类型的值
  %2 = apply %1<Int16>(%0) : $@convention(method) <τ_0_0> (@thin MemoryLayout<τ_0_0>.Type) -> Int // user: %3
  // 返回结果
  return %2 : $Int                                // id: %3
} // end sil function 'file.getSize() -> Swift.Int'

//  静态属性 size 的 get 方法
// static MemoryLayout.size.getter
sil [transparent] [serialized] @static Swift.MemoryLayout.size.getter : Swift.Int : $@convention(method) <τ_0_0> (@thin MemoryLayout<τ_0_0>.Type) -> Int

@frozen public enum MemoryLayout<T> {
  @_transparent public static var size: Swift.Int {
    @_transparent get {
    return Int(Builtin.sizeof(T.self))
  }
  }
  @_transparent public static var stride: Swift.Int {
    @_transparent get {
    return Int(Builtin.strideof(T.self))
  }
  }
  @_transparent public static var alignment: Swift.Int {
    @_transparent get {
    return Int(Builtin.alignof(T.self))
  }
  }
}

xcrun swiftc -emit-sil -Onone file.swift | swift demangle

//  静态属性 size 的 get 方法实现，对应的 Swift 版本就是  Int(Builtin.sizeof(T.self))
// static MemoryLayout.size.getter
sil public_external [transparent] [serialized] @static Swift.MemoryLayout.size.getter : Swift.Int : $@convention(method) <T> (@thin MemoryLayout<T>.Type) -> Int {
bb0(%0 : $@thin MemoryLayout<T>.Type):
  // 获得 T.Type 类型。
  %1 = metatype $@thick T.Type                    // user: %2
  // 调用内置函数 sizeof 获取 T.Type 类型的 size 信息，返回结果是 Builtin.Word 类型
  %2 = builtin "sizeof"<T>(%1 : $@thick T.Type) : $Builtin.Word // user: %3
  // 调用 sextOrBitCast_Word_Int64 将 Builtin.Word 类型的结果转为 Builtin.Int64 类型
  %3 = builtin "sextOrBitCast_Word_Int64"(%2 : $Builtin.Word) : $Builtin.Int64 // user: %4
  // 将 Builtin.Int64 类型转为 Int 类型
  %4 = struct $Int (%3 : $Builtin.Int64)          // user: %5
  return %4 : $Int                                // id: %5
} // end sil function 'static Swift.MemoryLayout.size.getter : Swift.Int'

sil_stage canonical

// getSize()
sil hidden @file.getSize() -> Swift.Int : $@convention(thin) () -> Int {
bb0:
  %0 = metatype $@thick Int16.Type                // user: %1
  %1 = builtin "sizeof"<Int16>(%0 : $@thick Int16.Type) : $Builtin.Word // user: %2
  %2 = builtin "sextOrBitCast_Word_Int64"(%1 : $Builtin.Word) : $Builtin.Int64 // user: %3
  %3 = struct $Int (%2 : $Builtin.Int64)          // user: %4
  return %3 : $Int                                // id: %4
} // end sil function 'file.getSize() -> Swift.Int'

@frozen public struct Int16 : Swift.FixedWidthInteger, Swift.SignedInteger, Swift._ExpressibleByBuiltinIntegerLiteral {
     public var _value: Builtin.Int16
 }

void BuiltinUnit::LookupCache::lookupValue(
       Identifier Name, NLKind LookupKind, const BuiltinUnit &M,
       SmallVectorImpl<ValueDecl*> &Result) {
...
   if (Type Ty = getBuiltinType(Ctx, Name.str())) {
      auto *TAD = new (Ctx) TypeAliasDecl(SourceLoc(), SourceLoc(),
                                          Name, SourceLoc(),
                                          /*genericparams*/nullptr,
                                          const_cast<BuiltinUnit*>(&M));
      TAD->setUnderlyingType(Ty);
      TAD->setAccess(AccessLevel::Public);
      Entry = TAD;
...

Type swift::getBuiltinType(ASTContext &Context, StringRef Name) 
····
  // Handle 'int8' and friends.
  if (Name.substr(0, 3) == "Int") {
    unsigned BitWidth;
    if (!Name.substr(3).getAsInteger(10, BitWidth) &&
        BitWidth <= 2048 && BitWidth != 0)  // Cap to prevent insane things.
      return BuiltinIntegerType::get(BitWidth, Context);
  }
····

(lldb) p Name
(swift::Identifier) $14 = (Pointer = "Int16")
(lldb) p Ty.dump()
(builtin_integer_type bit_width=16)
(lldb) p TAD->dump()
(typealias "Int16" access=public type='Builtin.Int16')

const TypeInfo *TypeConverter::convertStructType(TypeBase *key, CanType type,
                                                 StructDecl *D){

...
  // Collect all the fields from the type.
  SmallVector<VarDecl*, 8> fields;
  for (VarDecl *VD : D->getStoredProperties())
    fields.push_back(VD);

  // Build the type.
  StructTypeBuilder builder(IGM, ty, type);
  return builder.layout(fields);
}

TypeInfo *layout(ArrayRef<ASTField> astFields) {
    SmallVector<FieldImpl, 8> fields;
    SmallVector<const TypeInfo *, 8> fieldTypesForLayout;
    fields.reserve(astFields.size());
    fieldTypesForLayout.reserve(astFields.size());

    bool loadable = true;
    auto fieldsABIAccessible = FieldsAreABIAccessible;

    unsigned explosionSize = 0;
    for (unsigned i : indices(astFields)) {
      auto &astField = astFields[i];
      // Compute the field's type info.
      // 依次遍历获取 typeInfo 信息
      auto &fieldTI = IGM.getTypeInfo(asImpl()->getType(astField));
      fieldTypesForLayout.push_back(&fieldTI);

      if (!fieldTI.isABIAccessible())
        fieldsABIAccessible = FieldsAreNotABIAccessible;

      fields.push_back(FieldImpl(asImpl()->getFieldInfo(i, astField, fieldTI)));

      auto loadableFieldTI = dyn_cast<LoadableTypeInfo>(&fieldTI);
      if (!loadableFieldTI) {
        loadable = false;
        continue;
      }

      auto &fieldInfo = fields.back();
      fieldInfo.Begin = explosionSize;
      explosionSize += loadableFieldTI->getExplosionSize();
      fieldInfo.End = explosionSize;
    }

    // Perform layout and fill in the fields.
    // 产出 Int16 的 layout 信息
    StructLayout layout = asImpl()->performLayout(fieldTypesForLayout);
    for (unsigned i = 0, e = fields.size(); i != e; ++i) {
      fields[i].completeFrom(layout.getElements()[i]);
    }

    // Create the type info.
    if (loadable) {
      assert(layout.isFixedLayout());
      assert(fieldsABIAccessible);
      return asImpl()->createLoadable(fields, std::move(layout), explosionSize);
    } else if (layout.isFixedLayout()) {
      assert(fieldsABIAccessible);
      return asImpl()->createFixed(fields, std::move(layout));
    } else {
      return asImpl()->createNonFixed(fields, fieldsABIAccessible,
                                      std::move(layout));
    }
  }  
};

const TypeInfo *TypeConverter::getTypeEntry(CanType canonicalTy) {
  ...
  // 调用 convertType 函数，将 类型 转为 布局信息
  // Convert the type.
  auto *convertedTI = convertType(exemplarTy);
  ...
  return convertedTI;
}

(lldb) p exemplarTy.dump()
(builtin_integer_type bit_width=16)
(lldb) p *convertedTI
(const swift::irgen::TypeInfo) $7 = {
  Bits = {
    OpaqueBits = 8592015620
    TypeInfo = {
      Kind = 4
      AlignmentShift = 1
      POD = 1
      BitwiseTakable = 1
      SubclassKind = 7
      AlwaysFixedSize = 1
      ABIAccessible = 1
    }
    FixedTypeInfo = (Size = 2)
  }
  NextConverted = 0x0000000000000000
  StorageType = 0x000000012f009e28
  nativeReturnSchema = 0x0000000000000000
  nativeParameterSchema = 0x0000000000000000
}
(lldb) 

/// Convert a primitive builtin type to its LLVM type, size, and
/// alignment.
static std::tuple<llvm::Type *, Size, Alignment>
convertPrimitiveBuiltin(IRGenModule &IGM, CanType canTy) {
...
 case TypeKind::BuiltinInteger: {
    auto intTy = cast<BuiltinIntegerType>(ty);
    // 获取 bit 宽度
    unsigned BitWidth = IGM.getBuiltinIntegerWidth(intTy);
    // 转为 Byte 
    unsigned ByteSize = (BitWidth+7U)/8U;
    // Round up the memory size and alignment to a power of 2.
    if (!llvm::isPowerOf2_32(ByteSize))
      ByteSize = llvm::NextPowerOf2(ByteSize);

    return RetTy{ llvm::IntegerType::get(ctx, BitWidth), Size(ByteSize),
             Alignment(ByteSize) };
  }
...
}

unsigned IRGenModule::getBuiltinIntegerWidth(BuiltinIntegerType *t) {
  return getBuiltinIntegerWidth(t->getWidth());
}

class BuiltinIntegerType {
/// Return the bit width of the integer.  Always returns a non-arbitrary
  /// width.
  BuiltinIntegerWidth getWidth() const {
    return Width;
  }
}

xcrun swiftc -emit-ir -Xfrontend -disable-llvm-optzns -Onone file.swift | swift demangle

define hidden swiftcc i64 @"file.getSize() -> Swift.Int"() #0 {
entry:
  ret i64 2
}