golang/go · warning

printing assembly in Intel syntax is not supported

Error message

printing assembly in Intel syntax is not supported

What it means

The pprof tool's built-in Go-based disassembler (`objTool.Disasm`) was called with `intelSyntax=true`, but Intel syntax output is not implemented. The Go-native disassembly path uses the `disasm` package which only produces AT&T-syntax assembly. This limitation exists because the tool reimplements disassembly using Go libraries rather than invoking GNU binutils `objdump`.

Source

Thrown at src/cmd/pprof/pprof.go:193

		name: name,
		file: of,
	}
	if start != 0 {
		if load, err := of.LoadAddress(); err == nil {
			f.offset = start - load
		}
	}
	return f, nil
}

func (*objTool) Demangle(names []string) (map[string]string, error) {
	// No C++, nothing to demangle.
	return make(map[string]string), nil
}

func (t *objTool) Disasm(file string, start, end uint64, intelSyntax bool) ([]driver.Inst, error) {
	if intelSyntax {
		return nil, fmt.Errorf("printing assembly in Intel syntax is not supported")
	}
	d, err := t.cachedDisasm(file)
	if err != nil {
		return nil, err
	}
	var asm []driver.Inst
	d.Decode(start, end, nil, false, func(pc, size uint64, file string, line int, text string) {
		asm = append(asm, driver.Inst{Addr: pc, File: file, Line: line, Text: text})
	})
	return asm, nil
}

func (t *objTool) cachedDisasm(file string) (*disasm.Disasm, error) {
	t.mu.Lock()
	defer t.mu.Unlock()
	if t.disasmCache == nil {
		t.disasmCache = make(map[string]*disasm.Disasm)
	}

View on GitHub (pinned to b6b368adc5)

Solutions

1. Use AT&T syntax instead — pass `intelSyntax=false` or toggle the syntax option off in the pprof UI.
2. Install GNU binutils `objdump` on the system so pprof uses it instead of the built-in Go disassembler; objdump supports Intel syntax.
3. If Intel syntax is required for the built-in path, contribute an implementation to the Go project (the disasm package would need Intel syntax support).
4. Use an external disassembler (objdump, ndisasm) on the extracted binary as a workaround.

Example fix

# Before: requesting Intel syntax (fails with Go built-in disassembler)
pprof -http :8080 binary prof  # then select Intel in UI

# After: install objdump so Intel syntax works, or use AT&T syntax
# On Debian/Ubuntu:
sudo apt install binutils
# Or use AT&T syntax (default):
pprof -http :8080 binary prof

// Check if objdump is available for Intel syntax support
if _, err := exec.LookPath("objdump"); err == nil {
    // pprof will use objdump which supports Intel syntax
} else {
    // Must use AT&T syntax with built-in Go disassembler
    fmt.Println("Install binutils for Intel syntax support")
}

When it happens

Trigger: Fires in `objTool.Disasm` at pprof.go:191-193 when the `intelSyntax` parameter is true. This happens when the pprof web UI or CLI requests Intel syntax disassembly (commonly toggled in the pprof web interface or requested via the `-intel` option in the disassembly view).

Common situations: Clicking the 'Disassembly' link in the pprof web UI and selecting Intel syntax. Running pprof on a system where the native objdump is not available (so Go falls back to the built-in disassembler) and requesting Intel syntax. Developers more familiar with Intel syntax (common on Windows) trying to read disassembly on a Go-only system.

Related errors

• no DWARF data in go object file
• no DWARF data in Plan 9 file
• error processing pprof PGO profile: %w
• error parsing profile: %w
• profile does not contain a sample index with value/type "sam

AI-assisted analysis of golang/go@b6b368adc5 (2026-08-12). Data as JSON: /api/errors/c4131c27af1f9b8d. Report an issue: GitHub.