performance: readFile -> mmap

Author: rabarbra

go.mod

@@ -12,6 +12,7 @@ require (
 	github.com/ianlancetaylor/demangle v0.0.0-20260505044615-1ff4bf46051f
 	github.com/muesli/termenv v0.16.0
 	golang.org/x/arch v0.28.0
+	golang.org/x/sys v0.38.0
 	gopkg.in/yaml.v3 v3.0.1
 )
 
@@ -32,6 +33,5 @@ require (
 	github.com/muesli/cancelreader v0.2.2 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	golang.org/x/sys v0.38.0 // indirect
 	golang.org/x/text v0.3.8 // indirect
 )

internal/binfile/binfile.go

@@ -115,7 +115,8 @@ type File struct {
 	Symbols  []Symbol // sorted by Name
 	Info     *Info
 
-	raw       []byte // entire file contents (source for the raw view + section data)
+	raw       []byte       // entire file contents (mmap'd; source for the raw view + section data)
+	unmap     func() error // releases the mmap backing raw (nil-safe via Close)
 	arch      disasm.Arch
 	entry     uint64
 	addrWidth int // hex digits in a printed address (8 or 16)
@@ -141,29 +142,34 @@ type lineEntry struct {
 
 // Open reads path, detects its container format, and builds the neutral model.
 func Open(path string) (*File, error) {
-	raw, err := os.ReadFile(path)
+	raw, closer, err := mapFile(path)
 	if err != nil {
 		return nil, err
 	}
 	f := &File{
 		Path:    path,
 		raw:     raw,
+		unmap:   closer,
 		sources: map[string][]string{},
 	}
 	switch {
 	case len(raw) >= 4 && raw[0] == 0x7f && raw[1] == 'E' && raw[2] == 'L' && raw[3] == 'F':
 		if err := f.loadELF(); err != nil {
+			f.Close()
 			return nil, err
 		}
 	case isMachO(raw):
 		if err := f.loadMachO(); err != nil {
+			f.Close()
 			return nil, err
 		}
 	case len(raw) >= 2 && raw[0] == 'M' && raw[1] == 'Z':
 		if err := f.loadPE(); err != nil {
+			f.Close()
 			return nil, err
 		}
 	default:
+		f.Close()
 		return nil, fmt.Errorf("unrecognised file format (not ELF, Mach-O, or PE)")
 	}
 
@@ -172,6 +178,18 @@ func Open(path string) (*File, error) {
 	return f, nil
 }
 
+// Close releases the memory-mapped file. Safe to call more than once; after it
+// the raw bytes (and anything slicing into them) must no longer be used.
+func (f *File) Close() error {
+	if f == nil || f.unmap == nil {
+		return nil
+	}
+	err := f.unmap()
+	f.unmap = nil
+	f.raw = nil
+	return err
+}
+
 // finalizeSymbols sorts symbols, fills in missing sizes, and builds the
 // address-indexed copy used for reverse lookups. Loaders append unsorted
 // symbols with their Size left at 0 when the container doesn't record one

internal/binfile/mmap_other.go

@@ -0,0 +1,15 @@
+//go:build !unix
+
+package binfile
+
+import "os"
+
+// mapFile falls back to reading the whole file on platforms where we don't wire
+// up mmap (e.g. Windows). The closer is a no-op.
+func mapFile(path string) (data []byte, closer func() error, err error) {
+	b, err := os.ReadFile(path)
+	if err != nil {
+		return nil, nil, err
+	}
+	return b, func() error { return nil }, nil
+}

internal/binfile/mmap_unix.go

@@ -0,0 +1,44 @@
+//go:build unix
+
+package binfile
+
+import (
+	"os"
+
+	"golang.org/x/sys/unix"
+)
+
+// mapFile memory-maps path read-only and returns the bytes together with a
+// closer that unmaps them. Mapping avoids copying the whole file into the heap
+// (a 140 MB binary is otherwise a 140 MB allocation + read); pages fault in from
+// the page cache only as the parser touches them. The returned slice aliases the
+// mapping, so it stays valid until closer is called — keep it for the File's
+// lifetime. Empty files fall back to a nil slice (mmap rejects zero length).
+func mapFile(path string) (data []byte, closer func() error, err error) {
+	fh, err := os.Open(path)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer fh.Close()
+	fi, err := fh.Stat()
+	if err != nil {
+		return nil, nil, err
+	}
+	size := fi.Size()
+	if size <= 0 {
+		return nil, func() error { return nil }, nil
+	}
+	b, err := unix.Mmap(int(fh.Fd()), 0, int(size), unix.PROT_READ, unix.MAP_SHARED)
+	if err != nil {
+		// Fall back to a plain read when the file can't be mapped (e.g. a
+		// special file); correctness over speed.
+		data, rerr := os.ReadFile(path)
+		if rerr != nil {
+			return nil, nil, rerr
+		}
+		return data, func() error { return nil }, nil
+	}
+	// Advise the kernel we'll read it roughly sequentially; best-effort.
+	_ = unix.Madvise(b, unix.MADV_WILLNEED)
+	return b, func() error { return unix.Munmap(b) }, nil
+}