go-delve/delve · error

not implemented: %s

Error message

not implemented: %s

What it means

Delve's function-call injection walks every argument variable before a call and verifies its pointers can be tracked on the stack. When an argument variable has a reflect.Kind outside the supported set (strings, pointers/funcvals, and scalar numeric/bool/float/complex kinds), allPointers panics with this message. It signals an unsupported argument kind in the call-injection argument-scanning code, not a user error in the debugged program.

Source

Thrown at pkg/proc/fncall.go:784

			if err := allPointers(fv, fmt.Sprintf("%s.%s", name, field.Name), f); err != nil {
				return err
			}
		}
	case reflect.Array:
		for i := int64(0); i < v.Len; i++ {
			sv, _ := v.sliceAccess(int(i))
			if err := allPointers(sv, fmt.Sprintf("%s[%d]", name, i), f); err != nil {
				return err
			}
		}
	case reflect.Func:
		if err := f(v.funcvalAddr(), name); err != nil {
			return err
		}
	case reflect.Complex64, reflect.Complex128, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.Bool, reflect.Float32, reflect.Float64:
		// nothing to do
	default:
		panic(fmt.Errorf("not implemented: %s", v.Kind))
	}

	return nil
}

func pointerEscapes(addr uint64, stack stack, stacks []stack) bool {
	if addr >= stack.lo && addr < stack.hi {
		return false
	}
	for _, stack := range stacks {
		if addr >= stack.lo && addr < stack.hi {
			return false
		}
	}
	return true
}

const (

View on GitHub (pinned to a23773e6c3)

Solutions

1. Upgrade Delve to the latest version so the kind is supported
2. Reduce the argument to a supported type (plain int/uint/bool/float/string/pointer) before calling
3. Avoid injecting calls with unsafe.Pointer or func-valued arguments
4. File an issue with the Go version and the exact argument type if the kind should be supported

Example fix

// before
call myFn(unsafe.Pointer(&buf))
// after
call myFn((*byte)(&buf[0])) // pass a typed pointer instead

// Before issuing a 'call', check argument kinds are supported:
func argSupported(v *proc.Variable) bool {
	switch v.Kind {
	case reflect.String, reflect.Ptr, reflect.Func,
		reflect.Complex64, reflect.Complex128,
		reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
		reflect.Uintptr, reflect.Bool, reflect.Float32, reflect.Float64:
		return true
	}
	return false // unsupported kind would panic in allPointers
}

func isSupportedKind(k reflect.Kind) bool {
	switch k {
	case reflect.String, reflect.Ptr, reflect.Func,
		reflect.Complex64, reflect.Complex128,
		reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
		reflect.Uintptr, reflect.Bool, reflect.Float32, reflect.Float64:
		return true
	}
	return false
}

When it happens

Trigger: Calling a function via dlv's 'call' command whose argument (or a field/element reachable from it, since allPointers recurses into composites) has a kind not covered by the switch, e.g. a func value not caught by the funcval case, an unsafe.Pointer, or an unusual kind produced by a malformed DWARF type.

Common situations: Debugging with an unsupported or very new Go version that introduces a new DWARF type mapping; calling methods with exotic argument types (unsafe.Pointer, uintptr-wrapped handles); stale Delve version that predates support for a kind.

Related errors

• could not get precheck error reason: %v
• could not step out of %s: %v
• unknown or unsupported kind: %q
• could not decode first frame
• unable to find function context

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