src/debug/buildinfo/buildinfo.go - go - Git at Google

 // Copyright 2021 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 // Package buildinfo provides access to information embedded in a Go binary
 // about how it was built. This includes the Go toolchain version, and the
 // set of modules used (for binaries built in module mode).
 //
 // Build information is available for the currently running binary in
 // runtime/debug.ReadBuildInfo.
 package buildinfo

 import (
 	"bytes"
 	"debug/elf"
 	"debug/macho"
 	"debug/pe"
 	"encoding/binary"
 	"errors"
 	"fmt"
 	"internal/xcoff"
 	"io"
 	"io/fs"
 	"os"
 	"runtime/debug"
 )

 // Type alias for build info. We cannot move the types here, since
 // runtime/debug would need to import this package, which would make it
 // a much larger dependency.
 type BuildInfo = debug.BuildInfo

 var (
 	// errUnrecognizedFormat is returned when a given executable file doesn't
 	// appear to be in a known format, or it breaks the rules of that format,
 	// or when there are I/O errors reading the file.
 	errUnrecognizedFormat = errors.New("unrecognized file format")

 	// errNotGoExe is returned when a given executable file is valid but does
 	// not contain Go build information.
 	errNotGoExe = errors.New("not a Go executable")

 	// The build info blob left by the linker is identified by
 	// a 16-byte header, consisting of buildInfoMagic (14 bytes),
 	// the binary's pointer size (1 byte),
 	// and whether the binary is big endian (1 byte).
 	buildInfoMagic = []byte("\xff Go buildinf:")
 )

 // ReadFile returns build information embedded in a Go binary
 // file at the given path. Most information is only available for binaries built
 // with module support.
 func ReadFile(name string) (info *BuildInfo, err error) {
 	defer func() {
 		if pathErr := (*fs.PathError)(nil); errors.As(err, &pathErr) {
 			err = fmt.Errorf("could not read Go build info: %w", err)
 		} else if err != nil {
 			err = fmt.Errorf("could not read Go build info from %s: %w", name, err)
 		}
 	}()

 	f, err := os.Open(name)
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
 	return Read(f)
 }

 // Read returns build information embedded in a Go binary file
 // accessed through the given ReaderAt. Most information is only available for
 // binaries built with module support.
 func Read(r io.ReaderAt) (*BuildInfo, error) {
 	vers, mod, err := readRawBuildInfo(r)
 	if err != nil {
 		return nil, err
 	}
 	bi, err := debug.ParseBuildInfo(mod)
 	if err != nil {
 		return nil, err
 	}
 	bi.GoVersion = vers
 	return bi, nil
 }

 type exe interface {
 	// ReadData reads and returns up to size bytes starting at virtual address addr.
 	ReadData(addr, size uint64) ([]byte, error)

 	// DataStart returns the virtual address of the segment or section that
 	// should contain build information. This is either a specially named section
 	// or the first writable non-zero data segment.
 	DataStart() uint64
 }

 // readRawBuildInfo extracts the Go toolchain version and module information
 // strings from a Go binary. On success, vers should be non-empty. mod
 // is empty if the binary was not built with modules enabled.
 func readRawBuildInfo(r io.ReaderAt) (vers, mod string, err error) {
 	// Read the first bytes of the file to identify the format, then delegate to
 	// a format-specific function to load segment and section headers.
 	ident := make([]byte, 16)
 	if n, err := r.ReadAt(ident, 0); n < len(ident) || err != nil {
 		return "", "", errUnrecognizedFormat
 	}

 	var x exe
 	switch {
 	case bytes.HasPrefix(ident, []byte("\x7FELF")):
 		f, err := elf.NewFile(r)
 		if err != nil {
 			return "", "", errUnrecognizedFormat
 		}
 		x = &elfExe{f}
 	case bytes.HasPrefix(ident, []byte("MZ")):
 		f, err := pe.NewFile(r)
 		if err != nil {
 			return "", "", errUnrecognizedFormat
 		}
 		x = &peExe{f}
 	case bytes.HasPrefix(ident, []byte("\xFE\xED\xFA")) || bytes.HasPrefix(ident[1:], []byte("\xFA\xED\xFE")):
 		f, err := macho.NewFile(r)
 		if err != nil {
 			return "", "", errUnrecognizedFormat
 		}
 		x = &machoExe{f}
 	case bytes.HasPrefix(ident, []byte{0x01, 0xDF}) || bytes.HasPrefix(ident, []byte{0x01, 0xF7}):
 		f, err := xcoff.NewFile(r)
 		if err != nil {
 			return "", "", errUnrecognizedFormat
 		}
 		x = &xcoffExe{f}
 	default:
 		return "", "", errUnrecognizedFormat
 	}

 	// Read the first 64kB of dataAddr to find the build info blob.
 	// On some platforms, the blob will be in its own section, and DataStart
 	// returns the address of that section. On others, it's somewhere in the
 	// data segment; the linker puts it near the beginning.
 	// See cmd/link/internal/ld.Link.buildinfo.
 	dataAddr := x.DataStart()
 	data, err := x.ReadData(dataAddr, 64*1024)
 	if err != nil {
 		return "", "", err
 	}
 	const (
 		buildInfoAlign = 16
 		buildInfoSize  = 32
 	)
 	for {
 		i := bytes.Index(data, buildInfoMagic)
 		if i < 0 || len(data)-i < buildInfoSize {
 			return "", "", errNotGoExe
 		}
 		if i%buildInfoAlign == 0 && len(data)-i >= buildInfoSize {
 			data = data[i:]
 			break
 		}
 		data = data[(i+buildInfoAlign-1)&^buildInfoAlign:]
 	}

 	// Decode the blob.
 	// The first 14 bytes are buildInfoMagic.
 	// The next two bytes indicate pointer size in bytes (4 or 8) and endianness
 	// (0 for little, 1 for big).
 	// Two virtual addresses to Go strings follow that: runtime.buildVersion,
 	// and runtime.modinfo.
 	// On 32-bit platforms, the last 8 bytes are unused.
 	// If the endianness has the 2 bit set, then the pointers are zero
 	// and the 32-byte header is followed by varint-prefixed string data
 	// for the two string values we care about.
 	ptrSize := int(data[14])
 	if data[15]&2 != 0 {
 		vers, data = decodeString(data[32:])
 		mod, data = decodeString(data)
 	} else {
 		bigEndian := data[15] != 0
 		var bo binary.ByteOrder
 		if bigEndian {
 			bo = binary.BigEndian
 		} else {
 			bo = binary.LittleEndian
 		}
 		var readPtr func([]byte) uint64
 		if ptrSize == 4 {
 			readPtr = func(b []byte) uint64 { return uint64(bo.Uint32(b)) }
 		} else {
 			readPtr = bo.Uint64
 		}
 		vers = readString(x, ptrSize, readPtr, readPtr(data[16:]))
 		mod = readString(x, ptrSize, readPtr, readPtr(data[16+ptrSize:]))
 	}
 	if vers == "" {
 		return "", "", errNotGoExe
 	}
 	if len(mod) >= 33 && mod[len(mod)-17] == '\n' {
 		// Strip module framing: sentinel strings delimiting the module info.
 		// These are cmd/go/internal/modload.infoStart and infoEnd.
 		mod = mod[16 : len(mod)-16]
 	} else {
 		mod = ""
 	}

 	return vers, mod, nil
 }

 func decodeString(data []byte) (s string, rest []byte) {
 	u, n := binary.Uvarint(data)
 	if n <= 0 || u >= uint64(len(data)-n) {
 		return "", nil
 	}
 	return string(data[n : uint64(n)+u]), data[uint64(n)+u:]
 }

 // readString returns the string at address addr in the executable x.
 func readString(x exe, ptrSize int, readPtr func([]byte) uint64, addr uint64) string {
 	hdr, err := x.ReadData(addr, uint64(2*ptrSize))
 	if err != nil || len(hdr) < 2*ptrSize {
 		return ""
 	}
 	dataAddr := readPtr(hdr)
 	dataLen := readPtr(hdr[ptrSize:])
 	data, err := x.ReadData(dataAddr, dataLen)
 	if err != nil || uint64(len(data)) < dataLen {
 		return ""
 	}
 	return string(data)
 }

 // elfExe is the ELF implementation of the exe interface.
 type elfExe struct {
 	f *elf.File
 }

 func (x *elfExe) ReadData(addr, size uint64) ([]byte, error) {
 	for _, prog := range x.f.Progs {
 		if prog.Vaddr <= addr && addr <= prog.Vaddr+prog.Filesz-1 {
 			n := prog.Vaddr + prog.Filesz - addr
 			if n > size {
 				n = size
 			}
 			data := make([]byte, n)
 			_, err := prog.ReadAt(data, int64(addr-prog.Vaddr))
 			if err != nil {
 				return nil, err
 			}
 			return data, nil
 		}
 	}
 	return nil, errUnrecognizedFormat
 }

 func (x *elfExe) DataStart() uint64 {
 	for _, s := range x.f.Sections {
 		if s.Name == ".go.buildinfo" {
 			return s.Addr
 		}
 	}
 	for _, p := range x.f.Progs {
 		if p.Type == elf.PT_LOAD && p.Flags&(elf.PF_X|elf.PF_W) == elf.PF_W {
 			return p.Vaddr
 		}
 	}
 	return 0
 }

 // peExe is the PE (Windows Portable Executable) implementation of the exe interface.
 type peExe struct {
 	f *pe.File
 }

 func (x *peExe) imageBase() uint64 {
 	switch oh := x.f.OptionalHeader.(type) {
 	case *pe.OptionalHeader32:
 		return uint64(oh.ImageBase)
 	case *pe.OptionalHeader64:
 		return oh.ImageBase
 	}
 	return 0
 }

 func (x *peExe) ReadData(addr, size uint64) ([]byte, error) {
 	addr -= x.imageBase()
 	for _, sect := range x.f.Sections {
 		if uint64(sect.VirtualAddress) <= addr && addr <= uint64(sect.VirtualAddress+sect.Size-1) {
 			n := uint64(sect.VirtualAddress+sect.Size) - addr
 			if n > size {
 				n = size
 			}
 			data := make([]byte, n)
 			_, err := sect.ReadAt(data, int64(addr-uint64(sect.VirtualAddress)))
 			if err != nil {
 				return nil, errUnrecognizedFormat
 			}
 			return data, nil
 		}
 	}
 	return nil, errUnrecognizedFormat
 }

 func (x *peExe) DataStart() uint64 {
 	// Assume data is first writable section.
 	const (
 		IMAGE_SCN_CNT_CODE               = 0x00000020
 		IMAGE_SCN_CNT_INITIALIZED_DATA   = 0x00000040
 		IMAGE_SCN_CNT_UNINITIALIZED_DATA = 0x00000080
 		IMAGE_SCN_MEM_EXECUTE            = 0x20000000
 		IMAGE_SCN_MEM_READ               = 0x40000000
 		IMAGE_SCN_MEM_WRITE              = 0x80000000
 		IMAGE_SCN_MEM_DISCARDABLE        = 0x2000000
 		IMAGE_SCN_LNK_NRELOC_OVFL        = 0x1000000
 		IMAGE_SCN_ALIGN_32BYTES          = 0x600000
 	)
 	for _, sect := range x.f.Sections {
 		if sect.VirtualAddress != 0 && sect.Size != 0 &&
 			sect.Characteristics&^IMAGE_SCN_ALIGN_32BYTES == IMAGE_SCN_CNT_INITIALIZED_DATA|IMAGE_SCN_MEM_READ|IMAGE_SCN_MEM_WRITE {
 			return uint64(sect.VirtualAddress) + x.imageBase()
 		}
 	}
 	return 0
 }

 // machoExe is the Mach-O (Apple macOS/iOS) implementation of the exe interface.
 type machoExe struct {
 	f *macho.File
 }

 func (x *machoExe) ReadData(addr, size uint64) ([]byte, error) {
 	for _, load := range x.f.Loads {
 		seg, ok := load.(*macho.Segment)
 		if !ok {
 			continue
 		}
 		if seg.Addr <= addr && addr <= seg.Addr+seg.Filesz-1 {
 			if seg.Name == "__PAGEZERO" {
 				continue
 			}
 			n := seg.Addr + seg.Filesz - addr
 			if n > size {
 				n = size
 			}
 			data := make([]byte, n)
 			_, err := seg.ReadAt(data, int64(addr-seg.Addr))
 			if err != nil {
 				return nil, err
 			}
 			return data, nil
 		}
 	}
 	return nil, errUnrecognizedFormat
 }

 func (x *machoExe) DataStart() uint64 {
 	// Look for section named "__go_buildinfo".
 	for _, sec := range x.f.Sections {
 		if sec.Name == "__go_buildinfo" {
 			return sec.Addr
 		}
 	}
 	// Try the first non-empty writable segment.
 	const RW = 3
 	for _, load := range x.f.Loads {
 		seg, ok := load.(*macho.Segment)
 		if ok && seg.Addr != 0 && seg.Filesz != 0 && seg.Prot == RW && seg.Maxprot == RW {
 			return seg.Addr
 		}
 	}
 	return 0
 }

 // xcoffExe is the XCOFF (AIX eXtended COFF) implementation of the exe interface.
 type xcoffExe struct {
 	f *xcoff.File
 }

 func (x *xcoffExe) ReadData(addr, size uint64) ([]byte, error) {
 	for _, sect := range x.f.Sections {
 		if uint64(sect.VirtualAddress) <= addr && addr <= uint64(sect.VirtualAddress+sect.Size-1) {
 			n := uint64(sect.VirtualAddress+sect.Size) - addr
 			if n > size {
 				n = size
 			}
 			data := make([]byte, n)
 			_, err := sect.ReadAt(data, int64(addr-uint64(sect.VirtualAddress)))
 			if err != nil {
 				return nil, err
 			}
 			return data, nil
 		}
 	}
 	return nil, fmt.Errorf("address not mapped")
 }

 func (x *xcoffExe) DataStart() uint64 {
 	return x.f.SectionByType(xcoff.STYP_DATA).VirtualAddress
 }
	// Copyright 2021 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	// Package buildinfo provides access to information embedded in a Go binary
	// about how it was built. This includes the Go toolchain version, and the
	// set of modules used (for binaries built in module mode).
	//
	// Build information is available for the currently running binary in
	// runtime/debug.ReadBuildInfo.
	package buildinfo

	import (
	"bytes"
	"debug/elf"
	"debug/macho"
	"debug/pe"
	"encoding/binary"
	"errors"
	"fmt"
	"internal/xcoff"
	"io"
	"io/fs"
	"os"
	"runtime/debug"
	)

	// Type alias for build info. We cannot move the types here, since
	// runtime/debug would need to import this package, which would make it
	// a much larger dependency.
	type BuildInfo = debug.BuildInfo

	var (
	// errUnrecognizedFormat is returned when a given executable file doesn't
	// appear to be in a known format, or it breaks the rules of that format,
	// or when there are I/O errors reading the file.
	errUnrecognizedFormat = errors.New("unrecognized file format")

	// errNotGoExe is returned when a given executable file is valid but does
	// not contain Go build information.
	errNotGoExe = errors.New("not a Go executable")

	// The build info blob left by the linker is identified by
	// a 16-byte header, consisting of buildInfoMagic (14 bytes),
	// the binary's pointer size (1 byte),
	// and whether the binary is big endian (1 byte).
	buildInfoMagic = []byte("\xff Go buildinf:")
	)

	// ReadFile returns build information embedded in a Go binary
	// file at the given path. Most information is only available for binaries built
	// with module support.
	func ReadFile(name string) (info *BuildInfo, err error) {
	defer func() {
	if pathErr := (*fs.PathError)(nil); errors.As(err, &pathErr) {
	err = fmt.Errorf("could not read Go build info: %w", err)
	} else if err != nil {
	err = fmt.Errorf("could not read Go build info from %s: %w", name, err)
	}
	}()

	f, err := os.Open(name)
	if err != nil {
	return nil, err
	}
	defer f.Close()
	return Read(f)
	}

	// Read returns build information embedded in a Go binary file
	// accessed through the given ReaderAt. Most information is only available for
	// binaries built with module support.
	func Read(r io.ReaderAt) (*BuildInfo, error) {
	vers, mod, err := readRawBuildInfo(r)
	if err != nil {
	return nil, err
	}
	bi, err := debug.ParseBuildInfo(mod)
	if err != nil {
	return nil, err
	}
	bi.GoVersion = vers
	return bi, nil
	}

	type exe interface {
	// ReadData reads and returns up to size bytes starting at virtual address addr.
	ReadData(addr, size uint64) ([]byte, error)

	// DataStart returns the virtual address of the segment or section that
	// should contain build information. This is either a specially named section
	// or the first writable non-zero data segment.
	DataStart() uint64
	}

	// readRawBuildInfo extracts the Go toolchain version and module information
	// strings from a Go binary. On success, vers should be non-empty. mod
	// is empty if the binary was not built with modules enabled.
	func readRawBuildInfo(r io.ReaderAt) (vers, mod string, err error) {
	// Read the first bytes of the file to identify the format, then delegate to
	// a format-specific function to load segment and section headers.
	ident := make([]byte, 16)
	if n, err := r.ReadAt(ident, 0); n < len(ident) \|\| err != nil {
	return "", "", errUnrecognizedFormat
	}

	var x exe
	switch {
	case bytes.HasPrefix(ident, []byte("\x7FELF")):
	f, err := elf.NewFile(r)
	if err != nil {
	return "", "", errUnrecognizedFormat
	}
	x = &elfExe{f}
	case bytes.HasPrefix(ident, []byte("MZ")):
	f, err := pe.NewFile(r)
	if err != nil {
	return "", "", errUnrecognizedFormat
	}
	x = &peExe{f}
	case bytes.HasPrefix(ident, []byte("\xFE\xED\xFA")) \|\| bytes.HasPrefix(ident[1:], []byte("\xFA\xED\xFE")):
	f, err := macho.NewFile(r)
	if err != nil {
	return "", "", errUnrecognizedFormat
	}
	x = &machoExe{f}
	case bytes.HasPrefix(ident, []byte{0x01, 0xDF}) \|\| bytes.HasPrefix(ident, []byte{0x01, 0xF7}):
	f, err := xcoff.NewFile(r)
	if err != nil {
	return "", "", errUnrecognizedFormat
	}
	x = &xcoffExe{f}
	default:
	return "", "", errUnrecognizedFormat
	}

	// Read the first 64kB of dataAddr to find the build info blob.
	// On some platforms, the blob will be in its own section, and DataStart
	// returns the address of that section. On others, it's somewhere in the
	// data segment; the linker puts it near the beginning.
	// See cmd/link/internal/ld.Link.buildinfo.
	dataAddr := x.DataStart()
	data, err := x.ReadData(dataAddr, 64*1024)
	if err != nil {
	return "", "", err
	}
	const (
	buildInfoAlign = 16
	buildInfoSize = 32
	)
	for {
	i := bytes.Index(data, buildInfoMagic)
	if i < 0 \|\| len(data)-i < buildInfoSize {
	return "", "", errNotGoExe
	}
	if i%buildInfoAlign == 0 && len(data)-i >= buildInfoSize {
	data = data[i:]
	break
	}
	data = data[(i+buildInfoAlign-1)&^buildInfoAlign:]
	}

	// Decode the blob.
	// The first 14 bytes are buildInfoMagic.
	// The next two bytes indicate pointer size in bytes (4 or 8) and endianness
	// (0 for little, 1 for big).
	// Two virtual addresses to Go strings follow that: runtime.buildVersion,
	// and runtime.modinfo.
	// On 32-bit platforms, the last 8 bytes are unused.
	// If the endianness has the 2 bit set, then the pointers are zero
	// and the 32-byte header is followed by varint-prefixed string data
	// for the two string values we care about.
	ptrSize := int(data[14])
	if data[15]&2 != 0 {
	vers, data = decodeString(data[32:])
	mod, data = decodeString(data)
	} else {
	bigEndian := data[15] != 0
	var bo binary.ByteOrder
	if bigEndian {
	bo = binary.BigEndian
	} else {
	bo = binary.LittleEndian
	}
	var readPtr func([]byte) uint64
	if ptrSize == 4 {
	readPtr = func(b []byte) uint64 { return uint64(bo.Uint32(b)) }
	} else {
	readPtr = bo.Uint64
	}
	vers = readString(x, ptrSize, readPtr, readPtr(data[16:]))
	mod = readString(x, ptrSize, readPtr, readPtr(data[16+ptrSize:]))
	}
	if vers == "" {
	return "", "", errNotGoExe
	}
	if len(mod) >= 33 && mod[len(mod)-17] == '\n' {
	// Strip module framing: sentinel strings delimiting the module info.
	// These are cmd/go/internal/modload.infoStart and infoEnd.
	mod = mod[16 : len(mod)-16]
	} else {
	mod = ""
	}

	return vers, mod, nil
	}

	func decodeString(data []byte) (s string, rest []byte) {
	u, n := binary.Uvarint(data)
	if n <= 0 \|\| u >= uint64(len(data)-n) {
	return "", nil
	}
	return string(data[n : uint64(n)+u]), data[uint64(n)+u:]
	}

	// readString returns the string at address addr in the executable x.
	func readString(x exe, ptrSize int, readPtr func([]byte) uint64, addr uint64) string {
	hdr, err := x.ReadData(addr, uint64(2*ptrSize))
	if err != nil \|\| len(hdr) < 2*ptrSize {
	return ""
	}
	dataAddr := readPtr(hdr)
	dataLen := readPtr(hdr[ptrSize:])
	data, err := x.ReadData(dataAddr, dataLen)
	if err != nil \|\| uint64(len(data)) < dataLen {
	return ""
	}
	return string(data)
	}

	// elfExe is the ELF implementation of the exe interface.
	type elfExe struct {
	f *elf.File
	}

	func (x *elfExe) ReadData(addr, size uint64) ([]byte, error) {
	for _, prog := range x.f.Progs {
	if prog.Vaddr <= addr && addr <= prog.Vaddr+prog.Filesz-1 {
	n := prog.Vaddr + prog.Filesz - addr
	if n > size {
	n = size
	}
	data := make([]byte, n)
	_, err := prog.ReadAt(data, int64(addr-prog.Vaddr))
	if err != nil {
	return nil, err
	}
	return data, nil
	}
	}
	return nil, errUnrecognizedFormat
	}

	func (x *elfExe) DataStart() uint64 {
	for _, s := range x.f.Sections {
	if s.Name == ".go.buildinfo" {
	return s.Addr
	}
	}
	for _, p := range x.f.Progs {
	if p.Type == elf.PT_LOAD && p.Flags&(elf.PF_X\|elf.PF_W) == elf.PF_W {
	return p.Vaddr
	}
	}
	return 0
	}

	// peExe is the PE (Windows Portable Executable) implementation of the exe interface.
	type peExe struct {
	f *pe.File
	}

	func (x *peExe) imageBase() uint64 {
	switch oh := x.f.OptionalHeader.(type) {
	case *pe.OptionalHeader32:
	return uint64(oh.ImageBase)
	case *pe.OptionalHeader64:
	return oh.ImageBase
	}
	return 0
	}

	func (x *peExe) ReadData(addr, size uint64) ([]byte, error) {
	addr -= x.imageBase()
	for _, sect := range x.f.Sections {
	if uint64(sect.VirtualAddress) <= addr && addr <= uint64(sect.VirtualAddress+sect.Size-1) {
	n := uint64(sect.VirtualAddress+sect.Size) - addr
	if n > size {
	n = size
	}
	data := make([]byte, n)
	_, err := sect.ReadAt(data, int64(addr-uint64(sect.VirtualAddress)))
	if err != nil {
	return nil, errUnrecognizedFormat
	}
	return data, nil
	}
	}
	return nil, errUnrecognizedFormat
	}

	func (x *peExe) DataStart() uint64 {
	// Assume data is first writable section.
	const (
	IMAGE_SCN_CNT_CODE = 0x00000020
	IMAGE_SCN_CNT_INITIALIZED_DATA = 0x00000040
	IMAGE_SCN_CNT_UNINITIALIZED_DATA = 0x00000080
	IMAGE_SCN_MEM_EXECUTE = 0x20000000
	IMAGE_SCN_MEM_READ = 0x40000000
	IMAGE_SCN_MEM_WRITE = 0x80000000
	IMAGE_SCN_MEM_DISCARDABLE = 0x2000000
	IMAGE_SCN_LNK_NRELOC_OVFL = 0x1000000
	IMAGE_SCN_ALIGN_32BYTES = 0x600000
	)
	for _, sect := range x.f.Sections {
	if sect.VirtualAddress != 0 && sect.Size != 0 &&
	sect.Characteristics&^IMAGE_SCN_ALIGN_32BYTES == IMAGE_SCN_CNT_INITIALIZED_DATA\|IMAGE_SCN_MEM_READ\|IMAGE_SCN_MEM_WRITE {
	return uint64(sect.VirtualAddress) + x.imageBase()
	}
	}
	return 0
	}

	// machoExe is the Mach-O (Apple macOS/iOS) implementation of the exe interface.
	type machoExe struct {
	f *macho.File
	}

	func (x *machoExe) ReadData(addr, size uint64) ([]byte, error) {
	for _, load := range x.f.Loads {
	seg, ok := load.(*macho.Segment)
	if !ok {
	continue
	}
	if seg.Addr <= addr && addr <= seg.Addr+seg.Filesz-1 {
	if seg.Name == "__PAGEZERO" {
	continue
	}
	n := seg.Addr + seg.Filesz - addr
	if n > size {
	n = size
	}
	data := make([]byte, n)
	_, err := seg.ReadAt(data, int64(addr-seg.Addr))
	if err != nil {
	return nil, err
	}
	return data, nil
	}
	}
	return nil, errUnrecognizedFormat
	}

	func (x *machoExe) DataStart() uint64 {
	// Look for section named "__go_buildinfo".
	for _, sec := range x.f.Sections {
	if sec.Name == "__go_buildinfo" {
	return sec.Addr
	}
	}
	// Try the first non-empty writable segment.
	const RW = 3
	for _, load := range x.f.Loads {
	seg, ok := load.(*macho.Segment)
	if ok && seg.Addr != 0 && seg.Filesz != 0 && seg.Prot == RW && seg.Maxprot == RW {
	return seg.Addr
	}
	}
	return 0
	}

	// xcoffExe is the XCOFF (AIX eXtended COFF) implementation of the exe interface.
	type xcoffExe struct {
	f *xcoff.File
	}

	func (x *xcoffExe) ReadData(addr, size uint64) ([]byte, error) {
	for _, sect := range x.f.Sections {
	if uint64(sect.VirtualAddress) <= addr && addr <= uint64(sect.VirtualAddress+sect.Size-1) {
	n := uint64(sect.VirtualAddress+sect.Size) - addr
	if n > size {
	n = size
	}
	data := make([]byte, n)
	_, err := sect.ReadAt(data, int64(addr-uint64(sect.VirtualAddress)))
	if err != nil {
	return nil, err
	}
	return data, nil
	}
	}
	return nil, fmt.Errorf("address not mapped")
	}

	func (x *xcoffExe) DataStart() uint64 {
	return x.f.SectionByType(xcoff.STYP_DATA).VirtualAddress
	}