type TestStruct struct {
	ptr uintptr     // 8 
	f1  uint32      // 4
	f2  uint8       // 1
}

(dlv) p typ
*runtime._type {
	size: 16,
    ...

type TestStruct struct {
	ptr uintptr   // 8
	f1  uint8     // 1 
	f2  uint32    // 4
}

(dlv) p &a.ptr
(*uintptr)(0xc00008a010)
(dlv) p &a.f1
(*uint8)(0xc00008a018)
(dlv) p &a.f2
(*uint32)(0xc00008a01c)

type _type struct {
	size       uintptr
	ptrdata    uintptr // size of memory prefix holding all pointers
	hash       uint32
	tflag      tflag
	align      uint8
	fieldalign uint8
	kind       uint8
	alg        *typeAlg
	// gcdata stores the GC type data for the garbage collector.
	// If the KindGCProg bit is set in kind, gcdata is a GC program.
	// Otherwise it is a ptrmask bitmap. See mbitmap.go for details.
	gcdata    *byte
	str       nameOff
	ptrToThis typeOff
}

type TestStruct struct {
	ptr uintptr
	f1  uint8
	f2  *uint8
	f3  uint32
	f4  *uint64
	f5  uint64
}

(dlv) p typ
*runtime._type {
	size: 48,
	ptrdata: 40,
	hash: 4075663022,
	tflag: tflagUncommon|tflagExtraStar|tflagNamed (7),
	align: 8,
	fieldalign: 8,
	kind: 25,
	alg: *runtime.typeAlg {hash: type..hash.main.TestStruct, equal: type..eq.main.TestStruct},
	gcdata: *20,
	str: 28887,
	ptrToThis: 49504,}

func heapBitsSetType(x, size, dataSize uintptr, typ *_type) {
    // ...

    // 最重要的兩個步驟：
    // 通過分配地址反查獲取到 heap 的 heapBits 結(jié)構(gòu)（回憶下 golang 的內(nèi)存地址管理）
    h := heapBitsForAddr(x)
    // 獲取到類型的指針 bitmap；
    ptrmask := typ.gcdata // start of 1-bit pointer mask (or GC program, handled below)

    var (
        // ...
    )

    // 把 h.bitp 這個堆上的 bitmap 取出來；
    hbitp = h.bitp

    // 該類型的指針 bitmap
    p = ptrmask
    
    // ...
    if p != nil {
        // 把 bitmap 第一個字節(jié)保存起來
        b = uintptr(*p)
        // p 指向下一個字節(jié)
        p = add1(p)
        // 
        nb = 8
    }
    
    // 我們的是簡單的 Struct 結(jié)構(gòu)（48==48）
    if typ.size == dataSize {
        // nw == 5 == 40/8，說明掃描到第 5 個字段為止即可。
        // ptrdata 指明有指針的范圍在[0, 40]以內(nèi)，再往外確定就沒有指針字段了；
        nw = typ.ptrdata / sys.PtrSize
    } else {
        nw = ((dataSize/typ.size-1)*typ.size + typ.ptrdata) / sys.PtrSize
    }

    switch {
    default:
        throw("heapBitsSetType: unexpected shift")

    case h.shift == 0:
        // b 是類型的   ptr bitmap  =>  00010100
        //              bitPointerAll   =>  00001111
        // hb => 0000 0100
        hb = b & bitPointerAll
        // bitScan => 0001 0000 
        // 0001 0000 | 0100 0000 | 1000 0000 
        // hb => 1101 0100
        hb |= bitScan | bitScan<<(2*heapBitsShift) | bitScan<<(3*heapBitsShift)
        // 賦值 hbitp => 1101 0100
        *hbitp = uint8(hb)
        // 指針往后一個字節(jié)（遞進(jìn)一個字節(jié)）
        hbitp = add1(hbitp)
        // b => 0000 0001
        b >>= 4
        // nb => 4
        nb -= 4

    case sys.PtrSize == 8 && h.shift == 2:
        // ...
    }

    // ...
    // 處理完了前 4 bit，接下來處理后 4 bit
    nb -= 4
    for {
        // b => 0000 0001
        // hb => 0000 0001
        hb = b & bitPointerAll
        // hb => 1111 0001
        hb |= bitScanAll
        if w += 4; w >= nw {
            // 處理完了，有指針的字段都包含在已經(jīng)處理的 ptrmask 范圍內(nèi)了
            break
        }
        // ...
    }

Phase3:
    // Phase 3: Write last byte or partial byte and zero the rest of the bitmap entries.
    // 8 > 5
    if w > nw {
        // mask => 1
        mask := uintptr(1)<<(4-(w-nw)) - 1
        // hb => 0001 0001
        hb &= mask | mask<<4 // apply mask to both pointer bits and scan bits
    }

    // nw => 6
    nw = size / sys.PtrSize

    // ...

    if w == nw+2 {
        // 賦值 hbitp => 0001 0001
        *hbitp = *hbitp&^(bitPointer|bitScan|(bitPointer|bitScan)<<heapBitsShift) | uint8(hb)
    }

Phase4:
    // Phase 4: Copy unrolled bitmap to per-arena bitmaps, if necessary.
    // ...
}

func scanstack(gp *g, gcw *gcWork) {
    // ...
    // 掃描棧上所有的可達(dá)的對象
    state.buildIndex()
    for {
        p := state.getPtr()
        if p == 0 {
            break
        }
        // 獲取一個到棧上對象
        obj := state.findObject(p)
        if obj == nil {
            continue
        }
        // 獲取到這個對象的類型
        t := obj.typ
        // ...
        // 獲取到這個類型內(nèi)存塊的 ptr 的 bitmap（編譯期間編譯器設(shè)置好）
        gcdata := t.gcdata
        var s *mspan
        if t.kind&kindGCProg != 0 {
            s = materializeGCProg(t.ptrdata, gcdata)
            gcdata = (*byte)(unsafe.Pointer(s.startAddr))
        }

        // 掃描這個對象
        // 起點：對象起始地址 => state.stack.lo + obj.off
        // 終點：t.ptrdata （還記得這個吧，這個指明了指針?biāo)趦?nèi)的邊界）
        // 指針 bitmap：t.gcdata
        scanblock(state.stack.lo+uintptr(obj.off), t.ptrdata, gcdata, gcw, &state)

        if s != nil {
            dematerializeGCProg(s)
        }
    }
    // ...
}

/*
b0: 掃描開始的位置
n0: 掃描結(jié)束的長度
ptrmask: 指針的 bitmap
*/
func scanblock(b0, n0 uintptr, ptrmask *uint8, gcw *gcWork, stk *stackScanState) {
    b := b0
    n := n0
    // 掃描到長度 n 為止；
    for i := uintptr(0); i < n; {
        // 每個 bit 標(biāo)識一個 8 字節(jié)，8個 bit （1個字節(jié)）標(biāo)識 64 個字節(jié)；
        // 這里計算到合適的 bits
        bits := uint32(*addb(ptrmask, i/(sys.PtrSize*8)))
        // 如果整個 bits == 0，那么說明這 8 個 8 字節(jié)都沒有指針引用，可以直接跳到下一輪
        if bits == 0 {
            i += sys.PtrSize * 8
            continue
        }
        // bits 非0，說明內(nèi)部有指針引用，就必須一個個掃描查看；
        for j := 0; j < 8 && i < n; j++ {
            // 指針類型？只有標(biāo)識了指針類型的，才有可能走到下面的邏輯去；
            if bits&1 != 0 {
                p := *(*uintptr)(unsafe.Pointer(b + i))
                if p != 0 {
                    if obj, span, objIndex := findObject(p, b, i); obj != 0 {
                        // 如果這 8 字節(jié)指向的是可達(dá)的內(nèi)存對象，那么就投入掃描隊列（置灰）保護(hù)起來；
                        greyobject(obj, b, i, span, gcw, objIndex)
                    } else if stk != nil && p >= stk.stack.lo && p < stk.stack.hi {
                        stk.putPtr(p)
                    }
                }
            }
            bits >>= 1
            i += sys.PtrSize
        }
    }
}

type TestStruct struct {
	ptr uintptr
	f1  uint8
	f2  *uint8
	f3  uint32
	f4  *uint64
	f5  uint64
}

type TestStruct struct {
	ptr uintptr
	f1  uint8
	f2  *uint8
	f3  uint32
	f4  *uint64
	f5  uint64
}

(dlv) p typ
*runtime._type {
	size: 48,
	ptrdata: 40,
    ...
	gcdata: *20,
	... }

/*
b   : 是對象的內(nèi)存地址
gcw : 是掃描隊列的封裝
*/
func scanobject(b uintptr, gcw *gcWork) {
    // 通過對象地址 b 獲取到這塊內(nèi)存地址對應(yīng)的 hbits 
    hbits := heapBitsForAddr(b)
    // 通過對象地址 b 獲取到這塊內(nèi)存地址所在的 span
    s := spanOfUnchecked(b)
    // span 的元素大小
    n := s.elemsize
    if n == 0 {
        throw("scanobject n == 0")
    }
    // ...
    var i uintptr
    // 每 8 個字節(jié)處理遞進(jìn)處理(因為堆上對象分配都是 span，每個 span 的內(nèi)存塊都是定長的，所以掃描邊界就是 span.elemsize )
    for i = 0; i < n; i += sys.PtrSize {
        if i != 0 {
            hbits = hbits.next()
        }
        // 獲取到內(nèi)存塊的 bitmap
        bits := hbits.bits()
        
        // 確認(rèn)該整個內(nèi)存塊沒有指針，直接跳出，節(jié)約時間；
        if i != 1*sys.PtrSize && bits&bitScan == 0 {
            break // no more pointers in this object
        }
        // 確認(rèn) bits 對應(yīng)的小塊內(nèi)存沒有指針，所以可以直接到下一輪
        // 如果是指針，那么就往下看看這 8 字節(jié)啥情況
        if bits&bitPointer == 0 {
            continue // not a pointer
        }

        // 把這 8 字節(jié)里面存的值取出來；
        obj := *(*uintptr)(unsafe.Pointer(b + i))
        // 如果 obj 有值，并且合法（不在一個 span 的內(nèi)存塊里）
        if obj != 0 && obj-b >= n {
            // 如果 obj 指向一個有效的對象，那么把這個對象置灰色，投入掃描隊列，等待處理
            if obj, span, objIndex := findObject(obj, b, i); obj != 0 {
                greyobject(obj, b, i, span, gcw, objIndex)
            }
        }
    }
    // ...
}