go-delve/delve · warning

map type not yet supported by ebpf tracing

Error message

map type not yet supported by ebpf tracing

What it means

synthesizeTypeFromKind is the fallback that builds a synthetic godwarf type from the reflect.Kind recorded in the eBPF UProbeArgMap when no full DWARF type is available. Map parameters cannot be reconstructed from raw bytes this way, so instead of synthesizing a type the code marks the parameter Unreadable with this error. The tracepoint event still arrives, but this argument's value cannot be displayed.

Source

Thrown at pkg/proc/internal/ebpf/helpers.go:565

	case reflect.Pointer, reflect.UnsafePointer:
		iparam.Kind = reflect.Uintptr
		iparam.RealType = &godwarf.UintType{BasicType: godwarf.BasicType{CommonType: godwarf.CommonType{ByteSize: vs, ReflectKind: reflect.Uintptr}}}
	case reflect.Slice:
		iparam.Kind = reflect.Uintptr
		iparam.RealType = &godwarf.UintType{BasicType: godwarf.BasicType{CommonType: godwarf.CommonType{ByteSize: 8, ReflectKind: reflect.Uintptr}}}
	case reflect.String:
		if len(iparam.Data) >= 16 {
			iparam.Base = fakeAddressUnresolv + uint64(valSize)
			iparam.Len = int64(binary.LittleEndian.Uint64(iparam.Data[8:16]))
		}
		iparam.RealType = &godwarf.StringType{
			StructType: godwarf.StructType{
				CommonType: godwarf.CommonType{ByteSize: 16, ReflectKind: reflect.String},
				Kind:       "struct",
			},
		}
	case reflect.Map:
		iparam.Unreadable = fmt.Errorf("map type not yet supported by ebpf tracing")
	case reflect.Chan:
		iparam.Unreadable = fmt.Errorf("chan type not yet supported by ebpf tracing")
	case reflect.Interface:
		iparam.Unreadable = fmt.Errorf("interface type not yet supported by ebpf tracing")
	case reflect.Func:
		iparam.Unreadable = fmt.Errorf("func type not yet supported by ebpf tracing")
	case reflect.Struct:
		iparam.Unreadable = fmt.Errorf("struct type not yet supported by ebpf tracing without DWARF type")
	case reflect.Array:
		iparam.Unreadable = fmt.Errorf("array type not yet supported by ebpf tracing without DWARF type")
	default:
		iparam.Unreadable = fmt.Errorf("unrecognized reflect.Kind %d from eBPF", iparam.Kind)
	}
}

func createFunctionParameterList(entry uint64, goidOffset int64, args []UProbeArgMap, isret bool) function_parameter_list_t {
	var params function_parameter_list_t
	params.goid_offset = uint32(goidOffset)

View on GitHub (pinned to a23773e6c3)

Solutions

  1. Avoid tracing functions with map-typed parameters via eBPF, or wrap the call so the map is not a traced argument.
  2. Ensure the target binary retains full DWARF info (build without -w/-s, no strip) so breakpoints.go can resolve the argument's real DWARF type instead of falling back to Kind-only synthesis.
  3. Read other arguments of the event; only this parameter is marked Unreadable — handle the Unreadable error when displaying the variable.
  4. Follow delve releases; map support may be added to the eBPF type pipeline later.

Example fix

// before
dlv trace --ebpf mypkg.(*Cache).Update   // Update(m map[string]int)
// parameter shows: map type not yet supported by ebpf tracing
// after
// trace a wrapper exposing scalar fields instead:
func (c *Cache) UpdateSize() int { return len(c.m) }
dlv trace --ebpf mypkg.(*Cache).UpdateSize
Defensive patterns

Strategy: type-guard

Validate before calling

// Check the function's signature before tracing it with eBPF:
func hasUnsupportedParams(fn *proc.Function, bi *proc.BinaryInfo) bool {
	for _, p := range parameterTypes(fn, bi) {
		if p == nil {
			return true // unresolvable type will hit the Kind-only fallback
		}
		k := p.Common().ReflectKind
		if k == reflect.Map || k == reflect.Chan || k == reflect.Interface || k == reflect.Func || k == reflect.Struct || k == reflect.Array {
			return true
		}
	}
	return false
}

Type guard

func isEBPFSupportedKind(k reflect.Kind) bool {
	switch k {
	case 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, reflect.Complex64, reflect.Complex128,
		reflect.Pointer, reflect.UnsafePointer, reflect.Slice, reflect.String:
		return true
	}
	return false
}

Try / catch

for _, p := range traceEvent.InputParams {
	if p.Unreadable != nil {
		if strings.Contains(p.Unreadable.Error(), "map type not yet supported") {
			fmt.Printf("param %s: <unsupported: map>\n", p.Name)
			continue
		}
		return p.Unreadable
	}
	loadAndPrint(p)
}

Prevention

When it happens

Trigger: Tracing a function whose parameter (or return value) is a map, when the UProbeArgMap carries only the reflect.Kind (no resolvable DWARF type); handleParamEvent then calls synthesizeTypeFromKind, which hits 'case reflect.Map'.

Common situations: Running 'dlv trace --ebpf' on a function that takes a map argument (e.g. func f(m map[string]int)); tracing via the eBPF backend on stripped binaries or older pipelines where DWARF type resolution for the argument failed.

Related errors

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