go-delve/delve · warning

error accessing swiss map in table %d, group %d, slot %d

Error message

error accessing swiss map in table %d, group %d, slot %d

What it means

When walking a Go swiss map (Go 1.24+ map implementation), the iterator fetches the key/value (or slot) at the current table/group/slot position. If that slice access cannot read memory, iteration stops and the Variable is marked Unreadable with a message identifying the exact table, group, and slot.

Source

Thrown at pkg/proc/mapiter.go:551

			var slotsLen uint32
			if it.mapsplitgroup {
				slotsLen = uint32(it.group.keys.Len)
			} else {
				slotsLen = uint32(it.group.slots.Len)
			}
			for ; it.slotIdx < slotsLen; it.slotIdx++ {
				if it.slotIsEmptyOrDeleted(it.slotIdx) {
					continue
				}

				var err1, err2 error
				if it.mapsplitgroup {
					it.curKey, err1 = it.group.keys.sliceAccess(int(it.slotIdx))
					it.curValue, err2 = it.group.elems.sliceAccess(int(it.slotIdx))
				} else {
					cur, err := it.group.slots.sliceAccess(int(it.slotIdx))
					if err != nil {
						it.v.Unreadable = fmt.Errorf("error accessing swiss map in table %d, group %d, slot %d", it.dirIdx, it.groupIdx, it.slotIdx)
						return false
					}

					it.curKey, err1 = cur.toField(it.slotFieldKey)
					it.curValue, err2 = cur.toField(it.slotFieldElem)
				}
				if err1 != nil || err2 != nil {
					it.v.Unreadable = fmt.Errorf("error accessing swiss map slot: %v %v", err1, err2)
					return false
				}

				// If the type we expect is non-pointer but we read a pointer type it
				// means that the key (or the value) is stored indirectly into the map
				// because it is too big. We dereference it here so that the type of the
				// key (or value) matches the type on the map definition.
				if it.curKey.Kind == reflect.Ptr && !it.keyTypeIsPtr {
					it.curKey = it.curKey.maybeDereference()
				}

View on GitHub (pinned to a23773e6c3)

Solutions

1. Upgrade delve to a version matching the target's Go version (swiss map layout support)
2. Re-evaluate the map at the current stop point rather than reusing stale Variables
3. Verify core dump completeness or that the process memory is not corrupted

Example fix

// before
dlv --version # delve predates Go 1.24 swiss maps
// after
go install github.com/go-delve/delve/cmd/dlv@latest # matching Go 1.24+

if v.Unreadable != nil {
    return fmt.Errorf("map not readable: %v", v.Unreadable)
}
if !isSwissMapRuntime(goVersion) {
    return fmt.Errorf("upgrade delve for Go 1.24+ swiss maps")
}

func isReadable(v *proc.Variable) bool {
    return v.Unreadable == nil
}

ok := iterateMap(it)
if !ok && it.v.Unreadable != nil {
    if strings.Contains(it.v.Unreadable.Error(), "error accessing swiss map") {
        return reEvaluateAndIterate(mapExpr)
    }
    return it.v.Unreadable
}

When it happens

Trigger: Evaluating a swiss map whose group/slot memory is unreadable at the computed offsets — stale iterators across map growth, corrupted group pointers, or unreadable memory regions (e.g. missing core dump pages).

Common situations: Debugging programs built with Go 1.24+ swiss maps using an outdated delve; inspecting maps in core dumps with incomplete memory; holding Variable references across map mutations.

Related errors

• error accessing swiss map slot: %v %v
• could not load swiss table index field: %v
• wrong real type for map
• unreadable tophash: %v
• malformed map type: keys, values or tophash of a bucket is n

AI-assisted analysis of go-delve/delve@a23773e6c3 (2026-08-31). Data as JSON: /api/errors/8ccbcbf78a5a805e. Report an issue: GitHub.