go-delve/delve · error

malformed qMemoryRegionInfo response packet (size): %v in %s

Error message

malformed qMemoryRegionInfo response packet (size): %v in %s

What it means

This error is returned by memoryRegionInfo when the 'size' field of a qMemoryRegionInfo response packet fails strconv.ParseUint(value, 16, 64). The remote stub responded to qMemoryRegionInfo but its 'size:<hex>' value was not valid hexadecimal. Like the 'start' case, any unparseable field causes Delve to reject the whole response.

Source

Thrown at pkg/proc/gdbserial/gdbserver_conn.go:1295

	}

	mri := &memoryRegionInfo{}

	csp := colonSemicolonParser{buf: resp}
	for csp.next() {
		key, value := csp.key, csp.value

		switch string(key) {
		case "start":
			start, err := strconv.ParseUint(string(value), 16, 64)
			if err != nil {
				return nil, fmt.Errorf("malformed qMemoryRegionInfo response packet (start): %v in %s", err, string(resp))
			}
			mri.start = start
		case "size":
			size, err := strconv.ParseUint(string(value), 16, 64)
			if err != nil {
				return nil, fmt.Errorf("malformed qMemoryRegionInfo response packet (size): %v in %s", err, string(resp))
			}
			mri.size = size
		case "permissions":
			mri.permissions = string(value)
		case "name":
			namestr, ok := decodeHexString(value)
			if !ok {
				return nil, fmt.Errorf("malformed qMemoryRegionInfo response packet (name): %s", string(resp))
			}
			mri.name = namestr
		case "error":
			errstr, ok := decodeHexString(value)
			if !ok {
				return nil, fmt.Errorf("malformed qMemoryRegionInfo response packet (error): %s", string(resp))
			}
			return nil, fmt.Errorf("qMemoryRegionInfo error: %s", errstr)
		}
	}

View on GitHub (pinned to a23773e6c3)

Solutions

1. Fix the remote stub to emit 'size' as bare hex (e.g. size:1000) and ensure it fits in 64 bits
2. Inspect the full response string embedded in the error to identify the malformed value
3. Check whether the stub mistakenly echoes an error string inside the size field
4. Fall back to a backend/stub version with correct qMemoryRegionInfo support

Example fix

// stub before (malformed)
size:4096
// stub after (valid GDB RSP hex)
size:1000

func validHexSize(s string) bool {
    if s == "" { return false }
    _, err := strconv.ParseUint(s, 16, 64)
    return err == nil
}
// use: if !validHexSize(sizeField) { /* reject packet before use */ }

func regionSizeIsHex(resp []byte) bool {
    for _, kv := range bytes.Split(resp, []byte(",")) {
        parts := bytes.SplitN(kv, []byte(":"), 2)
        if len(parts) == 2 && string(parts[0]) == "size" {
            _, err := strconv.ParseUint(string(parts[1]), 16, 64)
            return err == nil
        }
    }
    return false
}

mri, err := conn.memoryRegionInfo(addr)
if err != nil {
    if strings.Contains(err.Error(), "malformed qMemoryRegionInfo response packet (size)") {
        log.Printf("stub sent invalid size field: %v", err)
        return nil
    }
    return err
}

When it happens

Trigger: Querying memory region information through the gdbserial backend when the remote stub's qMemoryRegionInfo reply contains a 'size' value that cannot be parsed as 64-bit hex (empty, decimal, 0x-prefixed, or overflowing 64 bits).

Common situations: Custom GDB RSP servers that report region sizes in decimal, stubs that omit the size field so the value is empty, embedded monitor stubs with buggy region enumeration, or a stub reporting a size larger than 2^64.

Understand the failure class

• Parsing and encoding errors: unexpected token, malformed input — why parsers reject input and how to find the real culprit.

Related errors

• malformed qMemoryRegionInfo response packet (start): %v in %
• qMemoryRegionInfo response wrapped around the address space
• too many transmit attempts
• malformed qfThreadInfo response
• could not determine executable path: %v

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