Merge pull request #4 from rabarbra/v0.2.4

V0.2.4

Author: rabarbra

.github/workflows/ci.yml

@@ -45,6 +45,9 @@ jobs:
             done
           } | tee -a "$GITHUB_STEP_SUMMARY"
 
+      - name: performance report (all views, startup, memory)
+        run: go run ./tools/perfreport exex-full
+
       - name: install mandoc
         run: sudo apt-get update && sudo apt-get install -y mandoc
 

.github/workflows/release.yml

@@ -23,6 +23,11 @@ jobs:
       - name: Build release archives
         run: make release VERSION="${GITHUB_REF_NAME}"
 
+      # Record this release's performance (all views, startup, memory) in the run
+      # summary, measured against the native build of exex itself.
+      - name: Performance report
+        run: make perf-report
+
       - uses: softprops/action-gh-release@v2
         with:
           files: dist/*

Makefile

@@ -13,7 +13,7 @@ BASHCOMPDIR ?= /usr/local/etc/bash_completion.d
 ZSHCOMPDIR ?= /usr/local/share/zsh/site-functions
 FISHCOMPDIR ?= /usr/local/share/fish/vendor_completions.d
 
-.PHONY: build lite install install-man install-completions test test-cross lint-docs size-report clean release
+.PHONY: build lite install install-man install-completions test test-cross lint-docs size-report perf-report clean release
 
 # Full build: includes Chroma syntax highlighting (source pane + asm colours).
 build:
@@ -56,6 +56,13 @@ lint-docs:
 size-report:
 	@sh scripts/size-report.sh $(BINARY)
 
+# Performance report: parse/startup cost, every -o view's render time and
+# allocation volume, and peak resident memory, measured against a sample binary
+# (default: exex itself — a realistic native object that is always present).
+# Override the target with SAMPLE=... ; appends to $GITHUB_STEP_SUMMARY in CI.
+perf-report: build
+	@go run ./tools/perfreport $(if $(SAMPLE),$(SAMPLE),./$(BINARY))
+
 # Slow, toolchain-dependent end-to-end test: cross-compile a tiny program with Go
 # and Zig for every target exex can read, then parse/disassemble each. Needs the
 # `go` and (for the Zig half) `zig` toolchains; missing targets are skipped.

docs/config.example.yaml

@@ -208,6 +208,16 @@ behavior:
   # the all-rows toggle also abbreviates symbol names in the disasm/hex/pointer
   # annotations. Toggle/save live from the settings popup (,).
   abbrev_args: false
+  # Disasm/hex display toggles (all default off; flip them live from the settings
+  # popup with ',').
+  # Hide the raw instruction-byte column in the disasm view (like objdump
+  # --no-show-raw-insn), reclaiming width for the code and source pane.
+  hide_disasm_bytes: false
+  # Hide the symbol/target annotations in the disasm and hex views.
+  hide_annotations: false
+  # Separate instruction bytes with spaces ("01 00 00 14") instead of the compact
+  # form ("01000014"), matching the `-o disasm` dump.
+  spaced_disasm_bytes: false
   # Where the disasm view lands by default (and redirects to when asked to show
   # a non-executable address): lowest, text, main, start, or entry. Defaults to
   # lowest (the lowest executable address). Unresolvable choices fall back.

internal/binfile/macho.go

@@ -590,7 +590,8 @@ func (f *File) loadMachOInfo(mf *macho.File) {
 	}
 
 	f.machoLoadInfo(mf, in)
-	in.Compiler = f.scanCompilerString()
+	// The compiler banner scan pages through __cstring/__const, which is costly on
+	// a cold open of a large Mach-O; defer it to f.Compiler() (first Info access).
 	f.Info = in
 }
 
@@ -827,6 +828,22 @@ func cstr(b []byte) string {
 	return string(b)
 }
 
+// Compiler returns the compiler banner ("Apple clang …", "GCC …", "rustc …"),
+// computed lazily on first call and cached. ELF fills Info.Compiler eagerly from
+// .comment during Open (cheap); Mach-O defers the section scan to here so a cold
+// Open doesn't page through __cstring/__const just to populate the Info view.
+func (f *File) Compiler() string {
+	if f.Info == nil {
+		return ""
+	}
+	f.compilerOnce.Do(func() {
+		if f.Info.Compiler == "" {
+			f.Info.Compiler = f.scanCompilerString()
+		}
+	})
+	return f.Info.Compiler
+}
+
 // scanCompilerString pulls a compiler banner out of likely string/comment
 // sections. Scanning the whole Mach-O image is expensive for large frameworks
 // and not needed for this optional metadata.

internal/binfile/model.go

@@ -182,6 +182,7 @@ type File struct {
 	dwarf        *dwarf.Data
 	dwarfAvail   bool               // DWARF is present (cheap check); HasDWARF without parsing
 	dwarfBuild   func() *dwarf.Data // builds dwarf lazily on first line/source lookup
+	compilerOnce sync.Once          // guards the lazy compiler-banner scan (Mach-O)
 	dwarfOnce    sync.Once          // guards the lazy DWARF decode
 	lines        []lineEntry        // sorted by Addr (loaded lazily from dwarf)
 	lineFiles    []string           // file-name table; lineEntry.File indexes into this

internal/binfile/parse_bench_test.go

@@ -0,0 +1,23 @@
+package binfile
+
+import (
+	"os"
+	"testing"
+)
+
+// BenchmarkOpen parses EXEX_BENCH_BIN; -benchmem/-memprofile/-cpuprofile
+// attribute the startup cost. Skipped unless the env var points at a real binary.
+func BenchmarkOpen(b *testing.B) {
+	path := os.Getenv("EXEX_BENCH_BIN")
+	if path == "" {
+		b.Skip("set EXEX_BENCH_BIN to a real binary")
+	}
+	b.ReportAllocs()
+	for range b.N {
+		f, err := Open(path)
+		if err != nil {
+			b.Fatal(err)
+		}
+		_ = f
+	}
+}

internal/config/config.go

@@ -64,6 +64,20 @@ type Behavior struct {
 	// (template arguments and parameter lists hidden). `d` toggles all and `.`
 	// toggles the row under the cursor for the session.
 	AbbrevArgs bool `yaml:"abbrev_args"`
+	// The three disasm/hex display toggles below are stored in the negative sense
+	// ("hide"/"spaced") so the zero value reproduces the historical default — a
+	// bool can't tell "absent" from "false", and Save writes every field
+	// explicitly. The settings modal presents them in the positive sense.
+	//
+	// HideDisasmBytes drops the raw instruction-byte column in the disasm view
+	// (like objdump --no-show-raw-insn), reclaiming width for the code/source.
+	HideDisasmBytes bool `yaml:"hide_disasm_bytes"`
+	// HideAnnotations drops the symbol/target annotations in the disasm and hex
+	// views.
+	HideAnnotations bool `yaml:"hide_annotations"`
+	// SpacedDisasmBytes separates instruction bytes with spaces ("01 00 00 14")
+	// instead of the compact form ("01000014"), matching the `-o disasm` dump.
+	SpacedDisasmBytes bool `yaml:"spaced_disasm_bytes"`
 }
 
 // Colors lists every visual element the user can re-skin. Empty strings mean
@@ -421,6 +435,9 @@ func Save(theme string, beh Behavior) (string, error) {
 	yamlBool("tree_libs", beh.TreeLibs)
 	yamlBool("tree_collapsed", beh.TreeCollapsed)
 	yamlBool("abbrev_args", beh.AbbrevArgs)
+	yamlBool("hide_disasm_bytes", beh.HideDisasmBytes)
+	yamlBool("hide_annotations", beh.HideAnnotations)
+	yamlBool("spaced_disasm_bytes", beh.SpacedDisasmBytes)
 
 	out, err := yaml.Marshal(&doc)
 	if err != nil {

internal/disasm/decoder.go

@@ -175,6 +175,20 @@ type Disassembler interface {
 	Name() string
 }
 
+// MaxInstLen returns the longest instruction encoding (in bytes) for an
+// architecture, used to size the byte column in disassembly views. Fixed-length
+// RISC ISAs need only their word size, so their column is much narrower than the
+// variable-length x86 cap; an unknown arch falls back to the x86 cap.
+func MaxInstLen(a Arch) int {
+	switch a {
+	case ArchARM64, ArchARM, ArchPPC64, ArchPPC64LE, ArchPPC, ArchPPCLE, ArchLoong64, ArchRISCV64:
+		return 4 // fixed 4 bytes (RISC-V's compressed forms are 2, still ≤ 4)
+	case ArchS390X:
+		return 6 // 2, 4 or 6
+	}
+	return 8 // x86/x86-64 are variable-length; cap the column as before
+}
+
 // For returns a single-instruction decoder for a supported architecture.
 func For(a Arch) (Disassembler, error) {
 	switch a {
@@ -271,7 +285,7 @@ func (arm64d) Decode(code []byte, addr uint64) (Inst, error) {
 	if err != nil {
 		return Inst{}, err
 	}
-	text := resolveRelTargets(arm64asm.GNUSyntax(inst), addr)
+	text := hexImmediates(resolveRelTargets(arm64asm.GNUSyntax(inst), addr))
 	return Inst{Addr: addr, Bytes: code[:4], Text: text, Class: Classify(text)}, nil
 }
 
@@ -373,7 +387,7 @@ func (armd) Decode(code []byte, addr uint64) (out Inst, err error) {
 	if n == 0 || n > len(code) {
 		n = 4
 	}
-	text := resolveRelTargets(armasm.GNUSyntax(inst), addr)
+	text := hexImmediates(resolveRelTargets(armasm.GNUSyntax(inst), addr))
 	return Inst{Addr: addr, Bytes: code[:n], Text: text, Class: Classify(text)}, nil
 }
 
@@ -478,6 +492,12 @@ func (loong64d) Decode(code []byte, addr uint64) (out Inst, err error) {
 // signed displacement (e.g. ".+0xfffffffffffffc58" is a negative jump); uint64
 // wraparound makes "addr + value" land on the right byte either way.
 func resolveRelTargets(text string, addr uint64) string {
+	// Fast path: only branch/PC-relative operands carry the ".+0x"/".-0x" form, so
+	// the vast majority of instructions need no rewrite — skip the allocation.
+	if !strings.Contains(text, ".+0x") && !strings.Contains(text, ".-0x") &&
+		!strings.Contains(text, ".+0X") && !strings.Contains(text, ".-0X") {
+		return text
+	}
 	var b strings.Builder
 	for i := 0; i < len(text); {
 		if text[i] == '.' && i+3 < len(text) &&
@@ -494,7 +514,7 @@ func resolveRelTargets(text string, addr uint64) string {
 					if text[i+1] == '-' {
 						target = addr - v
 					}
-					fmt.Fprintf(&b, "0x%x", target)
+					appendHexTo(&b, target)
 					i = j
 					continue
 				}
@@ -506,6 +526,66 @@ func resolveRelTargets(text string, addr uint64) string {
 	return b.String()
 }
 
+// hexImmediates rewrites the decimal immediates the ARM/ARM64 GNU syntaxers print
+// (e.g. memory offsets "[sp,#8]", "[sp,#-16]") into hex, so they read like objdump
+// ("[sp,#0x8]", "[sp,#-0x10]"). Immediates already in hex ("#0x40"), floats
+// ("#1.0") and any non-"#" use are left untouched; x86 immediates use "$" and are
+// already hex, so only the ARM-family decoders call this. The fast path returns
+// the input unchanged (no allocation) when there is no "#" to rewrite.
+func hexImmediates(s string) string {
+	if strings.IndexByte(s, '#') < 0 {
+		return s
+	}
+	var b strings.Builder
+	b.Grow(len(s) + 8)
+	for i := 0; i < len(s); {
+		if s[i] != '#' {
+			b.WriteByte(s[i])
+			i++
+			continue
+		}
+		j := i + 1
+		neg := false
+		if j < len(s) && (s[j] == '-' || s[j] == '+') {
+			neg = s[j] == '-'
+			j++
+		}
+		start := j
+		for j < len(s) && s[j] >= '0' && s[j] <= '9' {
+			j++
+		}
+		// Leave it alone unless this is a plain decimal: no digits, an "0x" hex
+		// prefix, or a "." float suffix all mean "not a decimal immediate".
+		if start == j || (j < len(s) && (s[j] == 'x' || s[j] == 'X' || s[j] == '.')) {
+			b.WriteByte('#')
+			i++
+			continue
+		}
+		v, err := strconv.ParseUint(s[start:j], 10, 64)
+		if err != nil {
+			b.WriteByte('#')
+			i++
+			continue
+		}
+		b.WriteByte('#')
+		if neg {
+			b.WriteByte('-')
+		}
+		appendHexTo(&b, v)
+		i = j
+	}
+	return b.String()
+}
+
+// appendHexTo writes "0x" + v in lowercase hex to b without fmt's interface
+// boxing — these decoders run on every instruction, so the dump/TUI decode paths
+// are allocation-sensitive. The scratch array stays on the stack.
+func appendHexTo(b *strings.Builder, v uint64) {
+	b.WriteString("0x")
+	var tmp [16]byte
+	b.Write(strconv.AppendUint(tmp[:0], v, 16))
+}
+
 // isHexDigit reports whether c is an ASCII hex digit.
 func isHexDigit(c byte) bool {
 	return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')