1
// 编译器生成的实际 bmap 布局（以 map[string]int 为例）
2
type bmap struct {
3
    tophash  [8]uint8      // 哈希高 8 位
4
    keys     [8]string     // 8 个 string key
5
    values   [8]int        // 8 个 int value
6
    overflow uintptr       // 溢出桶指针（用 uintptr 而非 *bmap，避免 GC 扫描）
7
}

1
v := m[key]     // => v := *mapaccess1(maptype, &m, &key)
2
v, ok := m[key] // => v, ok := mapaccess2(maptype, &m, &key)

1
// src/runtime/map.go（简化版）
2
func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
3
    hash := t.hasher(key, h.hash0)
4
    bucket := hash & bucketMask(h.B)
5

6
    b := (*bmap)(add(h.buckets, bucket*uintptr(t.bucketsize)))
7

8
    // 扩容期间：如果旧桶未搬迁，在旧桶中查找
9
    if h.growing() {
10
        oldBucket := hash & bucketMask(h.B - 1)
11
        oldB := (*bmap)(add(h.oldbuckets, oldBucket*uintptr(t.bucketsize)))
12
        if !evacuated(oldB) {
13
            b = oldB
14
        }
15
    }
16

17
    top := tophash(hash)
18
    for ; b != nil; b = b.overflow(t) {
19
        for i := uintptr(0); i < bucketCnt; i++ {
20
            if b.tophash[i] != top {
21
                // emptyRest：此槽及后续所有槽都空，直接结束查找
22
                if b.tophash[i] == emptyRest {
23
                    goto done
24
                }
25
                continue
26
            }
27
            // tophash 匹配，比较完整 key
28
            k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
29
            if t.key.equal(key, k) {
30
                // 找到！返回对应 value 的地址
31
                return add(unsafe.Pointer(b),
32
                    dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
33
            }
34
        }
35
    }
36
done:
37
    return zeroVal[0]  // 未找到，返回零值
38
}

1
# m[key] = "88" 的汇编片段
2
CALL runtime.mapassign_fast64(SB)  # 返回 value 地址到 DI
3
LEAQ  go.string."88"(SB), AX       # AX = &"88"
4
MOVQ  AX, (DI)                     # *DI = AX，完成赋值

1
// src/runtime/map.go（简化版，核心逻辑）
2
func mapassign(t *maptype, h *hmap, key unsafe.Pointer) {
3
    // 并发检测
4
    if h.flags&hashWriting != 0 {
5
        throw("concurrent map writes")
6
    }
7
    h.flags ^= hashWriting  // 用 XOR 设置写入标志
8

9
    hash := t.hasher(key, h.hash0)
10

11
    // 触发扩容（如果需要）
12
    if !h.growing() && (overLoadFactor(h.count+1, h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {
13
        hashGrow(t, h)
14
    }
15

16
    // 如果正在扩容，先搬迁当前桶
17
    if h.growing() {
18
        growWork(t, h, bucket)
19
    }
20

21
    bucket := hash & bucketMask(h.B)
22
    b := (*bmap)(add(h.buckets, bucket*uintptr(t.bucketsize)))
23
    top := tophash(hash)
24

25
    var inserti *uint8       // 记录第一个空槽的 tophash 地址
26
    var insertk unsafe.Pointer  // 记录第一个空槽的 key 地址
27

28
    for ; b != nil; b = b.overflow(t) {
29
        for i := uintptr(0); i < bucketCnt; i++ {
30
            if b.tophash[i] != top {
31
                // 记录第一个空槽，用于后续插入
32
                if isEmpty(b.tophash[i]) && inserti == nil {
33
                    inserti = &b.tophash[i]
34
                    insertk = add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
35
                }
36
                if b.tophash[i] == emptyRest {
37
                    goto done  // 后续都空，不用继续找
38
                }
39
                continue
40
            }
41
            // tophash 匹配，比较完整 key
42
            k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
43
            if t.key.equal(key, k) {
44
                // key 已存在，更新 value
45
                val := add(unsafe.Pointer(b),
46
                    dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
47
                typedmemmove(t.elem, val, val)
48
                goto done
49
            }
50
        }
51
    }
52

53
done:
54
    if inserti == nil {
55
        // 所有桶都满了，创建新的溢出桶
56
        newb := h.newoverflow(t, b)
57
        inserti = &newb.tophash[0]
58
        insertk = add(unsafe.Pointer(newb), dataOffset)
59
    }
60

61
    // 插入新 key
62
    *inserti = top
63
    typedmemmove(t.key, insertk, key)
64
    h.count++
65

66
    // 清除写入标志（XOR toggle off）
67
    h.flags ^= hashWriting
68
}

1
// src/runtime/map.go（关键控制流）
2
func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
3
    hash := t.hasher(key, h.hash0)
4
    h.flags ^= hashWriting
5

6
again:
7
    bucket := hash & bucketMask(h.B)
8
    // 扩容期间，先搬迁当前桶
9
    if h.growing() {
10
        growWork(t, h, bucket)
11
    }
12
    // ... 查找和插入逻辑
13

14
    // 触发扩容后跳回 again，重新定位桶
15
    if !h.growing() && (overLoadFactor(h.count+1, h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {
16
        hashGrow(t, h)
17
        goto again
18
    }
19
    // ...
20
}

1
// src/runtime/map.go（简化版）
2
func mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
3
    if h.flags&hashWriting != 0 {
4
        throw("concurrent map writes")
5
    }
6
    h.flags ^= hashWriting
7

8
    hash := t.hasher(key, h.hash0)
9

10
    // 扩容期间先搬迁当前桶
11
    if h.growing() {
12
        growWork(t, h, bucket)
13
    }
14

15
    b := (*bmap)(add(h.buckets, bucket*uintptr(t.bucketsize)))
16
    top := tophash(hash)
17

18
    for ; b != nil; b = b.overflow(t) {
19
        for i := uintptr(0); i < bucketCnt; i++ {
20
            if b.tophash[i] != top {
21
                if b.tophash[i] == emptyRest {
22
                    goto done  // 后续都空
23
                }
24
                continue
25
            }
26
            k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
27
            if t.key.equal(key, k) {
28
                // 找到 key，清除 key 和 value
29
                b.tophash[i] = emptyOne
30
                // 清除 key
31
                if t.key.ptrdata != 0 {
32
                    memclrHasPointers(k, t.key.size)
33
                }
34
                // 清除 value
35
                v := add(unsafe.Pointer(b),
36
                    dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
37
                if t.elem.ptrdata != 0 {
38
                    memclrHasPointers(v, t.elem.size)
39
                }
40
                h.count--
41

42
                // 检查后续槽是否都空，如果是则标记为 emptyRest
43
                // 这样下次查找可以提前终止
44
                // ...
45
                goto done
46
            }
47
        }
48
    }
49
done:
50
    h.flags ^= hashWriting
51
}

1
// src/runtime/map.go（emptyOne → emptyRest 提升）
2
// 删除 key 后，检查是否可以将 emptyOne 提升为 emptyRest
3
if i == 0 {
4
    // 当前是桶的第一个槽，检查溢出桶是否为空
5
    // 如果溢出桶链都为空，可以提升
6
    if b.overflow(t) != nil {
7
        goto done  // 还有溢出桶，不能提升
8
    }
9
} else if b.tophash[i-1] != emptyRest {
10
    goto done  // 前一个槽不是 emptyRest，不能提升
11
}
12
// 当前槽及后续都空，标记为 emptyRest
13
b.tophash[i] = emptyRest
14

15
// 向前回溯：如果前一个槽也是 emptyOne，继续提升为 emptyRest
16
// 这确保了整个空槽区间末尾的 emptyRest 传播

1
func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
2
    hash := t.hasher(key, h.hash0)
3
    m := bucketMask(h.B)
4
    b := (*bmap)(add(h.buckets, (hash&m)*uintptr(t.bucketsize)))
5

6
    if c := h.oldbuckets; c != nil {
7
        // 增量扩容：旧桶数是新桶数的一半，掩码右移一位
8
        if !h.sameSizeGrow() {
9
            m >>= 1
10
        }
11
        oldb := (*bmap)(add(c, (hash&m)*uintptr(t.bucketsize)))
12
        // 如果旧桶还没搬迁，在旧桶中查找
13
        if !evacuated(oldb) {
14
            b = oldb
15
        }
16
    }
17
    // ... 在 b 中查找
18
}

1
// src/runtime/map.go evacuate 内部
2
if !h.sameSizeGrow() {
3
    hash := t.hasher(k2, uintptr(h.hash0))
4
    // NaN key 的特殊处理：k2 != k2 说明是 NaN
5
    if h.flags&iterator != 0 && !t.reflexivekey && !t.key.equal(k2, k2) {
6
        if top&1 != 0 {
7
            hash |= newbit   // 强制第 B 位置 1 → 去 Y 部分
8
        } else {
9
            hash &^= newbit  // 强制第 B 位置 0 → 去 X 部分
10
        }
11
        // 重新计算 tophash，因为 hash 被修改了
12
        top = uint8(hash >> (sys.PtrSize*8 - 8))
13
        if top < minTopHash {
14
            top += minTopHash
15
        }
16
    }
17
    useY = hash & newbit
18
}

1
// 陷阱 1：不能取 map 元素的地址
2
// m["key"] 是不可寻址的（因为扩容时地址会变）
3
// _ = &m["key"]  // 编译错误
4

5
// 陷阱 2：nil map 可以读但不能写
6
var m map[string]int
7
_ = m["key"]  // 返回 0，不 panic
8
m["key"] = 1  // panic: assignment to entry in nil map
9

10
// 陷阱 3：遍历时修改
11
for k, v := range m {
12
    m[k] = v * 2  // 修改已有 key 是允许的
13
    m["new"] = 1  // 添加新 key → 运行时 panic
14
}