libgo/go/debug/pe/file.go - rust-lang/gcc - Git at Google

 // Copyright 2009 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 pe implements access to PE (Microsoft Windows Portable Executable) files.
 package pe

 import (
 	"bytes"
 	"compress/zlib"
 	"debug/dwarf"
 	"encoding/binary"
 	"fmt"
 	"io"
 	"os"
 	"strings"
 )

 // Avoid use of post-Go 1.4 io features, to make safe for toolchain bootstrap.
 const seekStart = 0

 // A File represents an open PE file.
 type File struct {
 	FileHeader
 	OptionalHeader any // of type *OptionalHeader32 or *OptionalHeader64
 	Sections       []*Section
 	Symbols        []*Symbol    // COFF symbols with auxiliary symbol records removed
 	COFFSymbols    []COFFSymbol // all COFF symbols (including auxiliary symbol records)
 	StringTable    StringTable

 	closer io.Closer
 }

 // Open opens the named file using os.Open and prepares it for use as a PE binary.
 func Open(name string) (*File, error) {
 	f, err := os.Open(name)
 	if err != nil {
 		return nil, err
 	}
 	ff, err := NewFile(f)
 	if err != nil {
 		f.Close()
 		return nil, err
 	}
 	ff.closer = f
 	return ff, nil
 }

 // Close closes the File.
 // If the File was created using NewFile directly instead of Open,
 // Close has no effect.
 func (f *File) Close() error {
 	var err error
 	if f.closer != nil {
 		err = f.closer.Close()
 		f.closer = nil
 	}
 	return err
 }

 // TODO(brainman): add Load function, as a replacement for NewFile, that does not call removeAuxSymbols (for performance)

 // NewFile creates a new File for accessing a PE binary in an underlying reader.
 func NewFile(r io.ReaderAt) (*File, error) {
 	f := new(File)
 	sr := io.NewSectionReader(r, 0, 1<<63-1)

 	var dosheader [96]byte
 	if _, err := r.ReadAt(dosheader[0:], 0); err != nil {
 		return nil, err
 	}
 	var base int64
 	if dosheader[0] == 'M' && dosheader[1] == 'Z' {
 		signoff := int64(binary.LittleEndian.Uint32(dosheader[0x3c:]))
 		var sign [4]byte
 		r.ReadAt(sign[:], signoff)
 		if !(sign[0] == 'P' && sign[1] == 'E' && sign[2] == 0 && sign[3] == 0) {
 			return nil, fmt.Errorf("invalid PE file signature: % x", sign)
 		}
 		base = signoff + 4
 	} else {
 		base = int64(0)
 	}
 	sr.Seek(base, seekStart)
 	if err := binary.Read(sr, binary.LittleEndian, &f.FileHeader); err != nil {
 		return nil, err
 	}
 	switch f.FileHeader.Machine {
 	case IMAGE_FILE_MACHINE_AMD64,
 		IMAGE_FILE_MACHINE_ARM64,
 		IMAGE_FILE_MACHINE_ARMNT,
 		IMAGE_FILE_MACHINE_I386,
 		IMAGE_FILE_MACHINE_UNKNOWN:
 		// ok
 	default:
 		return nil, fmt.Errorf("unrecognized PE machine: %#x", f.FileHeader.Machine)
 	}

 	var err error

 	// Read string table.
 	f.StringTable, err = readStringTable(&f.FileHeader, sr)
 	if err != nil {
 		return nil, err
 	}

 	// Read symbol table.
 	f.COFFSymbols, err = readCOFFSymbols(&f.FileHeader, sr)
 	if err != nil {
 		return nil, err
 	}
 	f.Symbols, err = removeAuxSymbols(f.COFFSymbols, f.StringTable)
 	if err != nil {
 		return nil, err
 	}

 	// Seek past file header.
 	_, err = sr.Seek(base+int64(binary.Size(f.FileHeader)), seekStart)
 	if err != nil {
 		return nil, err
 	}

 	// Read optional header.
 	f.OptionalHeader, err = readOptionalHeader(sr, f.FileHeader.SizeOfOptionalHeader)
 	if err != nil {
 		return nil, err
 	}

 	// Process sections.
 	f.Sections = make([]*Section, f.FileHeader.NumberOfSections)
 	for i := 0; i < int(f.FileHeader.NumberOfSections); i++ {
 		sh := new(SectionHeader32)
 		if err := binary.Read(sr, binary.LittleEndian, sh); err != nil {
 			return nil, err
 		}
 		name, err := sh.fullName(f.StringTable)
 		if err != nil {
 			return nil, err
 		}
 		s := new(Section)
 		s.SectionHeader = SectionHeader{
 			Name:                 name,
 			VirtualSize:          sh.VirtualSize,
 			VirtualAddress:       sh.VirtualAddress,
 			Size:                 sh.SizeOfRawData,
 			Offset:               sh.PointerToRawData,
 			PointerToRelocations: sh.PointerToRelocations,
 			PointerToLineNumbers: sh.PointerToLineNumbers,
 			NumberOfRelocations:  sh.NumberOfRelocations,
 			NumberOfLineNumbers:  sh.NumberOfLineNumbers,
 			Characteristics:      sh.Characteristics,
 		}
 		r2 := r
 		if sh.PointerToRawData == 0 { // .bss must have all 0s
 			r2 = zeroReaderAt{}
 		}
 		s.sr = io.NewSectionReader(r2, int64(s.SectionHeader.Offset), int64(s.SectionHeader.Size))
 		s.ReaderAt = s.sr
 		f.Sections[i] = s
 	}
 	for i := range f.Sections {
 		var err error
 		f.Sections[i].Relocs, err = readRelocs(&f.Sections[i].SectionHeader, sr)
 		if err != nil {
 			return nil, err
 		}
 	}

 	return f, nil
 }

 // zeroReaderAt is ReaderAt that reads 0s.
 type zeroReaderAt struct{}

 // ReadAt writes len(p) 0s into p.
 func (w zeroReaderAt) ReadAt(p []byte, off int64) (n int, err error) {
 	for i := range p {
 		p[i] = 0
 	}
 	return len(p), nil
 }

 // getString extracts a string from symbol string table.
 func getString(section []byte, start int) (string, bool) {
 	if start < 0 || start >= len(section) {
 		return "", false
 	}

 	for end := start; end < len(section); end++ {
 		if section[end] == 0 {
 			return string(section[start:end]), true
 		}
 	}
 	return "", false
 }

 // Section returns the first section with the given name, or nil if no such
 // section exists.
 func (f *File) Section(name string) *Section {
 	for _, s := range f.Sections {
 		if s.Name == name {
 			return s
 		}
 	}
 	return nil
 }

 func (f *File) DWARF() (*dwarf.Data, error) {
 	dwarfSuffix := func(s *Section) string {
 		switch {
 		case strings.HasPrefix(s.Name, ".debug_"):
 			return s.Name[7:]
 		case strings.HasPrefix(s.Name, ".zdebug_"):
 			return s.Name[8:]
 		default:
 			return ""
 		}

 	}

 	// sectionData gets the data for s and checks its size.
 	sectionData := func(s *Section) ([]byte, error) {
 		b, err := s.Data()
 		if err != nil && uint32(len(b)) < s.Size {
 			return nil, err
 		}

 		if 0 < s.VirtualSize && s.VirtualSize < s.Size {
 			b = b[:s.VirtualSize]
 		}

 		if len(b) >= 12 && string(b[:4]) == "ZLIB" {
 			dlen := binary.BigEndian.Uint64(b[4:12])
 			dbuf := make([]byte, dlen)
 			r, err := zlib.NewReader(bytes.NewBuffer(b[12:]))
 			if err != nil {
 				return nil, err
 			}
 			if _, err := io.ReadFull(r, dbuf); err != nil {
 				return nil, err
 			}
 			if err := r.Close(); err != nil {
 				return nil, err
 			}
 			b = dbuf
 		}
 		return b, nil
 	}

 	// There are many other DWARF sections, but these
 	// are the ones the debug/dwarf package uses.
 	// Don't bother loading others.
 	var dat = map[string][]byte{"abbrev": nil, "info": nil, "str": nil, "line": nil, "ranges": nil}
 	for _, s := range f.Sections {
 		suffix := dwarfSuffix(s)
 		if suffix == "" {
 			continue
 		}
 		if _, ok := dat[suffix]; !ok {
 			continue
 		}

 		b, err := sectionData(s)
 		if err != nil {
 			return nil, err
 		}
 		dat[suffix] = b
 	}

 	d, err := dwarf.New(dat["abbrev"], nil, nil, dat["info"], dat["line"], nil, dat["ranges"], dat["str"])
 	if err != nil {
 		return nil, err
 	}

 	// Look for DWARF4 .debug_types sections and DWARF5 sections.
 	for i, s := range f.Sections {
 		suffix := dwarfSuffix(s)
 		if suffix == "" {
 			continue
 		}
 		if _, ok := dat[suffix]; ok {
 			// Already handled.
 			continue
 		}

 		b, err := sectionData(s)
 		if err != nil {
 			return nil, err
 		}

 		if suffix == "types" {
 			err = d.AddTypes(fmt.Sprintf("types-%d", i), b)
 		} else {
 			err = d.AddSection(".debug_"+suffix, b)
 		}
 		if err != nil {
 			return nil, err
 		}
 	}

 	return d, nil
 }

 // TODO(brainman): document ImportDirectory once we decide what to do with it.

 type ImportDirectory struct {
 	OriginalFirstThunk uint32
 	TimeDateStamp      uint32
 	ForwarderChain     uint32
 	Name               uint32
 	FirstThunk         uint32

 	dll string
 }

 // ImportedSymbols returns the names of all symbols
 // referred to by the binary f that are expected to be
 // satisfied by other libraries at dynamic load time.
 // It does not return weak symbols.
 func (f *File) ImportedSymbols() ([]string, error) {
 	if f.OptionalHeader == nil {
 		return nil, nil
 	}

 	pe64 := f.Machine == IMAGE_FILE_MACHINE_AMD64 || f.Machine == IMAGE_FILE_MACHINE_ARM64

 	// grab the number of data directory entries
 	var dd_length uint32
 	if pe64 {
 		dd_length = f.OptionalHeader.(*OptionalHeader64).NumberOfRvaAndSizes
 	} else {
 		dd_length = f.OptionalHeader.(*OptionalHeader32).NumberOfRvaAndSizes
 	}

 	// check that the length of data directory entries is large
 	// enough to include the imports directory.
 	if dd_length < IMAGE_DIRECTORY_ENTRY_IMPORT+1 {
 		return nil, nil
 	}

 	// grab the import data directory entry
 	var idd DataDirectory
 	if pe64 {
 		idd = f.OptionalHeader.(*OptionalHeader64).DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT]
 	} else {
 		idd = f.OptionalHeader.(*OptionalHeader32).DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT]
 	}

 	// figure out which section contains the import directory table
 	var ds *Section
 	ds = nil
 	for _, s := range f.Sections {
 		if s.VirtualAddress <= idd.VirtualAddress && idd.VirtualAddress < s.VirtualAddress+s.VirtualSize {
 			ds = s
 			break
 		}
 	}

 	// didn't find a section, so no import libraries were found
 	if ds == nil {
 		return nil, nil
 	}

 	d, err := ds.Data()
 	if err != nil {
 		return nil, err
 	}

 	// seek to the virtual address specified in the import data directory
 	d = d[idd.VirtualAddress-ds.VirtualAddress:]

 	// start decoding the import directory
 	var ida []ImportDirectory
 	for len(d) >= 20 {
 		var dt ImportDirectory
 		dt.OriginalFirstThunk = binary.LittleEndian.Uint32(d[0:4])
 		dt.TimeDateStamp = binary.LittleEndian.Uint32(d[4:8])
 		dt.ForwarderChain = binary.LittleEndian.Uint32(d[8:12])
 		dt.Name = binary.LittleEndian.Uint32(d[12:16])
 		dt.FirstThunk = binary.LittleEndian.Uint32(d[16:20])
 		d = d[20:]
 		if dt.OriginalFirstThunk == 0 {
 			break
 		}
 		ida = append(ida, dt)
 	}
 	// TODO(brainman): this needs to be rewritten
 	//  ds.Data() returns contents of section containing import table. Why store in variable called "names"?
 	//  Why we are retrieving it second time? We already have it in "d", and it is not modified anywhere.
 	//  getString does not extracts a string from symbol string table (as getString doco says).
 	//  Why ds.Data() called again and again in the loop?
 	//  Needs test before rewrite.
 	names, _ := ds.Data()
 	var all []string
 	for _, dt := range ida {
 		dt.dll, _ = getString(names, int(dt.Name-ds.VirtualAddress))
 		d, _ = ds.Data()
 		// seek to OriginalFirstThunk
 		d = d[dt.OriginalFirstThunk-ds.VirtualAddress:]
 		for len(d) > 0 {
 			if pe64 { // 64bit
 				va := binary.LittleEndian.Uint64(d[0:8])
 				d = d[8:]
 				if va == 0 {
 					break
 				}
 				if va&0x8000000000000000 > 0 { // is Ordinal
 					// TODO add dynimport ordinal support.
 				} else {
 					fn, _ := getString(names, int(uint32(va)-ds.VirtualAddress+2))
 					all = append(all, fn+":"+dt.dll)
 				}
 			} else { // 32bit
 				va := binary.LittleEndian.Uint32(d[0:4])
 				d = d[4:]
 				if va == 0 {
 					break
 				}
 				if va&0x80000000 > 0 { // is Ordinal
 					// TODO add dynimport ordinal support.
 					//ord := va&0x0000FFFF
 				} else {
 					fn, _ := getString(names, int(va-ds.VirtualAddress+2))
 					all = append(all, fn+":"+dt.dll)
 				}
 			}
 		}
 	}

 	return all, nil
 }

 // ImportedLibraries returns the names of all libraries
 // referred to by the binary f that are expected to be
 // linked with the binary at dynamic link time.
 func (f *File) ImportedLibraries() ([]string, error) {
 	// TODO
 	// cgo -dynimport don't use this for windows PE, so just return.
 	return nil, nil
 }

 // FormatError is unused.
 // The type is retained for compatibility.
 type FormatError struct {
 }

 func (e *FormatError) Error() string {
 	return "unknown error"
 }

 // readOptionalHeader accepts a io.ReadSeeker pointing to optional header in the PE file
 // and its size as seen in the file header.
 // It parses the given size of bytes and returns optional header. It infers whether the
 // bytes being parsed refer to 32 bit or 64 bit version of optional header.
 func readOptionalHeader(r io.ReadSeeker, sz uint16) (any, error) {
 	// If optional header size is 0, return empty optional header.
 	if sz == 0 {
 		return nil, nil
 	}

 	var (
 		// First couple of bytes in option header state its type.
 		// We need to read them first to determine the type and
 		// validity of optional header.
 		ohMagic   uint16
 		ohMagicSz = binary.Size(ohMagic)
 	)

 	// If optional header size is greater than 0 but less than its magic size, return error.
 	if sz < uint16(ohMagicSz) {
 		return nil, fmt.Errorf("optional header size is less than optional header magic size")
 	}

 	// read reads from io.ReadSeeke, r, into data.
 	var err error
 	read := func(data any) bool {
 		err = binary.Read(r, binary.LittleEndian, data)
 		return err == nil
 	}

 	if !read(&ohMagic) {
 		return nil, fmt.Errorf("failure to read optional header magic: %v", err)

 	}

 	switch ohMagic {
 	case 0x10b: // PE32
 		var (
 			oh32 OptionalHeader32
 			// There can be 0 or more data directories. So the minimum size of optional
 			// header is calculated by subtracting oh32.DataDirectory size from oh32 size.
 			oh32MinSz = binary.Size(oh32) - binary.Size(oh32.DataDirectory)
 		)

 		if sz < uint16(oh32MinSz) {
 			return nil, fmt.Errorf("optional header size(%d) is less minimum size (%d) of PE32 optional header", sz, oh32MinSz)
 		}

 		// Init oh32 fields
 		oh32.Magic = ohMagic
 		if !read(&oh32.MajorLinkerVersion) ||
 			!read(&oh32.MinorLinkerVersion) ||
 			!read(&oh32.SizeOfCode) ||
 			!read(&oh32.SizeOfInitializedData) ||
 			!read(&oh32.SizeOfUninitializedData) ||
 			!read(&oh32.AddressOfEntryPoint) ||
 			!read(&oh32.BaseOfCode) ||
 			!read(&oh32.BaseOfData) ||
 			!read(&oh32.ImageBase) ||
 			!read(&oh32.SectionAlignment) ||
 			!read(&oh32.FileAlignment) ||
 			!read(&oh32.MajorOperatingSystemVersion) ||
 			!read(&oh32.MinorOperatingSystemVersion) ||
 			!read(&oh32.MajorImageVersion) ||
 			!read(&oh32.MinorImageVersion) ||
 			!read(&oh32.MajorSubsystemVersion) ||
 			!read(&oh32.MinorSubsystemVersion) ||
 			!read(&oh32.Win32VersionValue) ||
 			!read(&oh32.SizeOfImage) ||
 			!read(&oh32.SizeOfHeaders) ||
 			!read(&oh32.CheckSum) ||
 			!read(&oh32.Subsystem) ||
 			!read(&oh32.DllCharacteristics) ||
 			!read(&oh32.SizeOfStackReserve) ||
 			!read(&oh32.SizeOfStackCommit) ||
 			!read(&oh32.SizeOfHeapReserve) ||
 			!read(&oh32.SizeOfHeapCommit) ||
 			!read(&oh32.LoaderFlags) ||
 			!read(&oh32.NumberOfRvaAndSizes) {
 			return nil, fmt.Errorf("failure to read PE32 optional header: %v", err)
 		}

 		dd, err := readDataDirectories(r, sz-uint16(oh32MinSz), oh32.NumberOfRvaAndSizes)
 		if err != nil {
 			return nil, err
 		}

 		copy(oh32.DataDirectory[:], dd)

 		return &oh32, nil
 	case 0x20b: // PE32+
 		var (
 			oh64 OptionalHeader64
 			// There can be 0 or more data directories. So the minimum size of optional
 			// header is calculated by subtracting oh64.DataDirectory size from oh64 size.
 			oh64MinSz = binary.Size(oh64) - binary.Size(oh64.DataDirectory)
 		)

 		if sz < uint16(oh64MinSz) {
 			return nil, fmt.Errorf("optional header size(%d) is less minimum size (%d) for PE32+ optional header", sz, oh64MinSz)
 		}

 		// Init oh64 fields
 		oh64.Magic = ohMagic
 		if !read(&oh64.MajorLinkerVersion) ||
 			!read(&oh64.MinorLinkerVersion) ||
 			!read(&oh64.SizeOfCode) ||
 			!read(&oh64.SizeOfInitializedData) ||
 			!read(&oh64.SizeOfUninitializedData) ||
 			!read(&oh64.AddressOfEntryPoint) ||
 			!read(&oh64.BaseOfCode) ||
 			!read(&oh64.ImageBase) ||
 			!read(&oh64.SectionAlignment) ||
 			!read(&oh64.FileAlignment) ||
 			!read(&oh64.MajorOperatingSystemVersion) ||
 			!read(&oh64.MinorOperatingSystemVersion) ||
 			!read(&oh64.MajorImageVersion) ||
 			!read(&oh64.MinorImageVersion) ||
 			!read(&oh64.MajorSubsystemVersion) ||
 			!read(&oh64.MinorSubsystemVersion) ||
 			!read(&oh64.Win32VersionValue) ||
 			!read(&oh64.SizeOfImage) ||
 			!read(&oh64.SizeOfHeaders) ||
 			!read(&oh64.CheckSum) ||
 			!read(&oh64.Subsystem) ||
 			!read(&oh64.DllCharacteristics) ||
 			!read(&oh64.SizeOfStackReserve) ||
 			!read(&oh64.SizeOfStackCommit) ||
 			!read(&oh64.SizeOfHeapReserve) ||
 			!read(&oh64.SizeOfHeapCommit) ||
 			!read(&oh64.LoaderFlags) ||
 			!read(&oh64.NumberOfRvaAndSizes) {
 			return nil, fmt.Errorf("failure to read PE32+ optional header: %v", err)
 		}

 		dd, err := readDataDirectories(r, sz-uint16(oh64MinSz), oh64.NumberOfRvaAndSizes)
 		if err != nil {
 			return nil, err
 		}

 		copy(oh64.DataDirectory[:], dd)

 		return &oh64, nil
 	default:
 		return nil, fmt.Errorf("optional header has unexpected Magic of 0x%x", ohMagic)
 	}
 }

 // readDataDirectories accepts a io.ReadSeeker pointing to data directories in the PE file,
 // its size and number of data directories as seen in optional header.
 // It parses the given size of bytes and returns given number of data directories.
 func readDataDirectories(r io.ReadSeeker, sz uint16, n uint32) ([]DataDirectory, error) {
 	ddSz := binary.Size(DataDirectory{})
 	if uint32(sz) != n*uint32(ddSz) {
 		return nil, fmt.Errorf("size of data directories(%d) is inconsistent with number of data directories(%d)", sz, n)
 	}

 	dd := make([]DataDirectory, n)
 	if err := binary.Read(r, binary.LittleEndian, dd); err != nil {
 		return nil, fmt.Errorf("failure to read data directories: %v", err)
 	}

 	return dd, nil
 }
	// Copyright 2009 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 pe implements access to PE (Microsoft Windows Portable Executable) files.
	package pe

	import (
	"bytes"
	"compress/zlib"
	"debug/dwarf"
	"encoding/binary"
	"fmt"
	"io"
	"os"
	"strings"
	)

	// Avoid use of post-Go 1.4 io features, to make safe for toolchain bootstrap.
	const seekStart = 0

	// A File represents an open PE file.
	type File struct {
	FileHeader
	OptionalHeader any // of type OptionalHeader32 or OptionalHeader64
	Sections []*Section
	Symbols []*Symbol // COFF symbols with auxiliary symbol records removed
	COFFSymbols []COFFSymbol // all COFF symbols (including auxiliary symbol records)
	StringTable StringTable

	closer io.Closer
	}

	// Open opens the named file using os.Open and prepares it for use as a PE binary.
	func Open(name string) (*File, error) {
	f, err := os.Open(name)
	if err != nil {
	return nil, err
	}
	ff, err := NewFile(f)
	if err != nil {
	f.Close()
	return nil, err
	}
	ff.closer = f
	return ff, nil
	}

	// Close closes the File.
	// If the File was created using NewFile directly instead of Open,
	// Close has no effect.
	func (f *File) Close() error {
	var err error
	if f.closer != nil {
	err = f.closer.Close()
	f.closer = nil
	}
	return err
	}

	// TODO(brainman): add Load function, as a replacement for NewFile, that does not call removeAuxSymbols (for performance)

	// NewFile creates a new File for accessing a PE binary in an underlying reader.
	func NewFile(r io.ReaderAt) (*File, error) {
	f := new(File)
	sr := io.NewSectionReader(r, 0, 1<<63-1)

	var dosheader [96]byte
	if _, err := r.ReadAt(dosheader[0:], 0); err != nil {
	return nil, err
	}
	var base int64
	if dosheader[0] == 'M' && dosheader[1] == 'Z' {
	signoff := int64(binary.LittleEndian.Uint32(dosheader[0x3c:]))
	var sign [4]byte
	r.ReadAt(sign[:], signoff)
	if !(sign[0] == 'P' && sign[1] == 'E' && sign[2] == 0 && sign[3] == 0) {
	return nil, fmt.Errorf("invalid PE file signature: % x", sign)
	}
	base = signoff + 4
	} else {
	base = int64(0)
	}
	sr.Seek(base, seekStart)
	if err := binary.Read(sr, binary.LittleEndian, &f.FileHeader); err != nil {
	return nil, err
	}
	switch f.FileHeader.Machine {
	case IMAGE_FILE_MACHINE_AMD64,
	IMAGE_FILE_MACHINE_ARM64,
	IMAGE_FILE_MACHINE_ARMNT,
	IMAGE_FILE_MACHINE_I386,
	IMAGE_FILE_MACHINE_UNKNOWN:
	// ok
	default:
	return nil, fmt.Errorf("unrecognized PE machine: %#x", f.FileHeader.Machine)
	}

	var err error

	// Read string table.
	f.StringTable, err = readStringTable(&f.FileHeader, sr)
	if err != nil {
	return nil, err
	}

	// Read symbol table.
	f.COFFSymbols, err = readCOFFSymbols(&f.FileHeader, sr)
	if err != nil {
	return nil, err
	}
	f.Symbols, err = removeAuxSymbols(f.COFFSymbols, f.StringTable)
	if err != nil {
	return nil, err
	}

	// Seek past file header.
	_, err = sr.Seek(base+int64(binary.Size(f.FileHeader)), seekStart)
	if err != nil {
	return nil, err
	}

	// Read optional header.
	f.OptionalHeader, err = readOptionalHeader(sr, f.FileHeader.SizeOfOptionalHeader)
	if err != nil {
	return nil, err
	}

	// Process sections.
	f.Sections = make([]*Section, f.FileHeader.NumberOfSections)
	for i := 0; i < int(f.FileHeader.NumberOfSections); i++ {
	sh := new(SectionHeader32)
	if err := binary.Read(sr, binary.LittleEndian, sh); err != nil {
	return nil, err
	}
	name, err := sh.fullName(f.StringTable)
	if err != nil {
	return nil, err
	}
	s := new(Section)
	s.SectionHeader = SectionHeader{
	Name: name,
	VirtualSize: sh.VirtualSize,
	VirtualAddress: sh.VirtualAddress,
	Size: sh.SizeOfRawData,
	Offset: sh.PointerToRawData,
	PointerToRelocations: sh.PointerToRelocations,
	PointerToLineNumbers: sh.PointerToLineNumbers,
	NumberOfRelocations: sh.NumberOfRelocations,
	NumberOfLineNumbers: sh.NumberOfLineNumbers,
	Characteristics: sh.Characteristics,
	}
	r2 := r
	if sh.PointerToRawData == 0 { // .bss must have all 0s
	r2 = zeroReaderAt{}
	}
	s.sr = io.NewSectionReader(r2, int64(s.SectionHeader.Offset), int64(s.SectionHeader.Size))
	s.ReaderAt = s.sr
	f.Sections[i] = s
	}
	for i := range f.Sections {
	var err error
	f.Sections[i].Relocs, err = readRelocs(&f.Sections[i].SectionHeader, sr)
	if err != nil {
	return nil, err
	}
	}

	return f, nil
	}

	// zeroReaderAt is ReaderAt that reads 0s.
	type zeroReaderAt struct{}

	// ReadAt writes len(p) 0s into p.
	func (w zeroReaderAt) ReadAt(p []byte, off int64) (n int, err error) {
	for i := range p {
	p[i] = 0
	}
	return len(p), nil
	}

	// getString extracts a string from symbol string table.
	func getString(section []byte, start int) (string, bool) {
	if start < 0 \|\| start >= len(section) {
	return "", false
	}

	for end := start; end < len(section); end++ {
	if section[end] == 0 {
	return string(section[start:end]), true
	}
	}
	return "", false
	}

	// Section returns the first section with the given name, or nil if no such
	// section exists.
	func (f File) Section(name string) Section {
	for _, s := range f.Sections {
	if s.Name == name {
	return s
	}
	}
	return nil
	}

	func (f File) DWARF() (dwarf.Data, error) {
	dwarfSuffix := func(s *Section) string {
	switch {
	case strings.HasPrefix(s.Name, ".debug_"):
	return s.Name[7:]
	case strings.HasPrefix(s.Name, ".zdebug_"):
	return s.Name[8:]
	default:
	return ""
	}

	}

	// sectionData gets the data for s and checks its size.
	sectionData := func(s *Section) ([]byte, error) {
	b, err := s.Data()
	if err != nil && uint32(len(b)) < s.Size {
	return nil, err
	}

	if 0 < s.VirtualSize && s.VirtualSize < s.Size {
	b = b[:s.VirtualSize]
	}

	if len(b) >= 12 && string(b[:4]) == "ZLIB" {
	dlen := binary.BigEndian.Uint64(b[4:12])
	dbuf := make([]byte, dlen)
	r, err := zlib.NewReader(bytes.NewBuffer(b[12:]))
	if err != nil {
	return nil, err
	}
	if _, err := io.ReadFull(r, dbuf); err != nil {
	return nil, err
	}
	if err := r.Close(); err != nil {
	return nil, err
	}
	b = dbuf
	}
	return b, nil
	}

	// There are many other DWARF sections, but these
	// are the ones the debug/dwarf package uses.
	// Don't bother loading others.
	var dat = map[string][]byte{"abbrev": nil, "info": nil, "str": nil, "line": nil, "ranges": nil}
	for _, s := range f.Sections {
	suffix := dwarfSuffix(s)
	if suffix == "" {
	continue
	}
	if _, ok := dat[suffix]; !ok {
	continue
	}

	b, err := sectionData(s)
	if err != nil {
	return nil, err
	}
	dat[suffix] = b
	}

	d, err := dwarf.New(dat["abbrev"], nil, nil, dat["info"], dat["line"], nil, dat["ranges"], dat["str"])
	if err != nil {
	return nil, err
	}

	// Look for DWARF4 .debug_types sections and DWARF5 sections.
	for i, s := range f.Sections {
	suffix := dwarfSuffix(s)
	if suffix == "" {
	continue
	}
	if _, ok := dat[suffix]; ok {
	// Already handled.
	continue
	}

	b, err := sectionData(s)
	if err != nil {
	return nil, err
	}

	if suffix == "types" {
	err = d.AddTypes(fmt.Sprintf("types-%d", i), b)
	} else {
	err = d.AddSection(".debug_"+suffix, b)
	}
	if err != nil {
	return nil, err
	}
	}

	return d, nil
	}

	// TODO(brainman): document ImportDirectory once we decide what to do with it.

	type ImportDirectory struct {
	OriginalFirstThunk uint32
	TimeDateStamp uint32
	ForwarderChain uint32
	Name uint32
	FirstThunk uint32

	dll string
	}

	// ImportedSymbols returns the names of all symbols
	// referred to by the binary f that are expected to be
	// satisfied by other libraries at dynamic load time.
	// It does not return weak symbols.
	func (f *File) ImportedSymbols() ([]string, error) {
	if f.OptionalHeader == nil {
	return nil, nil
	}

	pe64 := f.Machine == IMAGE_FILE_MACHINE_AMD64 \|\| f.Machine == IMAGE_FILE_MACHINE_ARM64

	// grab the number of data directory entries
	var dd_length uint32
	if pe64 {
	dd_length = f.OptionalHeader.(*OptionalHeader64).NumberOfRvaAndSizes
	} else {
	dd_length = f.OptionalHeader.(*OptionalHeader32).NumberOfRvaAndSizes
	}

	// check that the length of data directory entries is large
	// enough to include the imports directory.
	if dd_length < IMAGE_DIRECTORY_ENTRY_IMPORT+1 {
	return nil, nil
	}

	// grab the import data directory entry
	var idd DataDirectory
	if pe64 {
	idd = f.OptionalHeader.(*OptionalHeader64).DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT]
	} else {
	idd = f.OptionalHeader.(*OptionalHeader32).DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT]
	}

	// figure out which section contains the import directory table
	var ds *Section
	ds = nil
	for _, s := range f.Sections {
	if s.VirtualAddress <= idd.VirtualAddress && idd.VirtualAddress < s.VirtualAddress+s.VirtualSize {
	ds = s
	break
	}
	}

	// didn't find a section, so no import libraries were found
	if ds == nil {
	return nil, nil
	}

	d, err := ds.Data()
	if err != nil {
	return nil, err
	}

	// seek to the virtual address specified in the import data directory
	d = d[idd.VirtualAddress-ds.VirtualAddress:]

	// start decoding the import directory
	var ida []ImportDirectory
	for len(d) >= 20 {
	var dt ImportDirectory
	dt.OriginalFirstThunk = binary.LittleEndian.Uint32(d[0:4])
	dt.TimeDateStamp = binary.LittleEndian.Uint32(d[4:8])
	dt.ForwarderChain = binary.LittleEndian.Uint32(d[8:12])
	dt.Name = binary.LittleEndian.Uint32(d[12:16])
	dt.FirstThunk = binary.LittleEndian.Uint32(d[16:20])
	d = d[20:]
	if dt.OriginalFirstThunk == 0 {
	break
	}
	ida = append(ida, dt)
	}
	// TODO(brainman): this needs to be rewritten
	// ds.Data() returns contents of section containing import table. Why store in variable called "names"?
	// Why we are retrieving it second time? We already have it in "d", and it is not modified anywhere.
	// getString does not extracts a string from symbol string table (as getString doco says).
	// Why ds.Data() called again and again in the loop?
	// Needs test before rewrite.
	names, _ := ds.Data()
	var all []string
	for _, dt := range ida {
	dt.dll, _ = getString(names, int(dt.Name-ds.VirtualAddress))
	d, _ = ds.Data()
	// seek to OriginalFirstThunk
	d = d[dt.OriginalFirstThunk-ds.VirtualAddress:]
	for len(d) > 0 {
	if pe64 { // 64bit
	va := binary.LittleEndian.Uint64(d[0:8])
	d = d[8:]
	if va == 0 {
	break
	}
	if va&0x8000000000000000 > 0 { // is Ordinal
	// TODO add dynimport ordinal support.
	} else {
	fn, _ := getString(names, int(uint32(va)-ds.VirtualAddress+2))
	all = append(all, fn+":"+dt.dll)
	}
	} else { // 32bit
	va := binary.LittleEndian.Uint32(d[0:4])
	d = d[4:]
	if va == 0 {
	break
	}
	if va&0x80000000 > 0 { // is Ordinal
	// TODO add dynimport ordinal support.
	//ord := va&0x0000FFFF
	} else {
	fn, _ := getString(names, int(va-ds.VirtualAddress+2))
	all = append(all, fn+":"+dt.dll)
	}
	}
	}
	}

	return all, nil
	}

	// ImportedLibraries returns the names of all libraries
	// referred to by the binary f that are expected to be
	// linked with the binary at dynamic link time.
	func (f *File) ImportedLibraries() ([]string, error) {
	// TODO
	// cgo -dynimport don't use this for windows PE, so just return.
	return nil, nil
	}

	// FormatError is unused.
	// The type is retained for compatibility.
	type FormatError struct {
	}

	func (e *FormatError) Error() string {
	return "unknown error"
	}

	// readOptionalHeader accepts a io.ReadSeeker pointing to optional header in the PE file
	// and its size as seen in the file header.
	// It parses the given size of bytes and returns optional header. It infers whether the
	// bytes being parsed refer to 32 bit or 64 bit version of optional header.
	func readOptionalHeader(r io.ReadSeeker, sz uint16) (any, error) {
	// If optional header size is 0, return empty optional header.
	if sz == 0 {
	return nil, nil
	}

	var (
	// First couple of bytes in option header state its type.
	// We need to read them first to determine the type and
	// validity of optional header.
	ohMagic uint16
	ohMagicSz = binary.Size(ohMagic)
	)

	// If optional header size is greater than 0 but less than its magic size, return error.
	if sz < uint16(ohMagicSz) {
	return nil, fmt.Errorf("optional header size is less than optional header magic size")
	}

	// read reads from io.ReadSeeke, r, into data.
	var err error
	read := func(data any) bool {
	err = binary.Read(r, binary.LittleEndian, data)
	return err == nil
	}

	if !read(&ohMagic) {
	return nil, fmt.Errorf("failure to read optional header magic: %v", err)

	}

	switch ohMagic {
	case 0x10b: // PE32
	var (
	oh32 OptionalHeader32
	// There can be 0 or more data directories. So the minimum size of optional
	// header is calculated by subtracting oh32.DataDirectory size from oh32 size.
	oh32MinSz = binary.Size(oh32) - binary.Size(oh32.DataDirectory)
	)

	if sz < uint16(oh32MinSz) {
	return nil, fmt.Errorf("optional header size(%d) is less minimum size (%d) of PE32 optional header", sz, oh32MinSz)
	}

	// Init oh32 fields
	oh32.Magic = ohMagic
	if !read(&oh32.MajorLinkerVersion) \|\|
	!read(&oh32.MinorLinkerVersion) \|\|
	!read(&oh32.SizeOfCode) \|\|
	!read(&oh32.SizeOfInitializedData) \|\|
	!read(&oh32.SizeOfUninitializedData) \|\|
	!read(&oh32.AddressOfEntryPoint) \|\|
	!read(&oh32.BaseOfCode) \|\|
	!read(&oh32.BaseOfData) \|\|
	!read(&oh32.ImageBase) \|\|
	!read(&oh32.SectionAlignment) \|\|
	!read(&oh32.FileAlignment) \|\|
	!read(&oh32.MajorOperatingSystemVersion) \|\|
	!read(&oh32.MinorOperatingSystemVersion) \|\|
	!read(&oh32.MajorImageVersion) \|\|
	!read(&oh32.MinorImageVersion) \|\|
	!read(&oh32.MajorSubsystemVersion) \|\|
	!read(&oh32.MinorSubsystemVersion) \|\|
	!read(&oh32.Win32VersionValue) \|\|
	!read(&oh32.SizeOfImage) \|\|
	!read(&oh32.SizeOfHeaders) \|\|
	!read(&oh32.CheckSum) \|\|
	!read(&oh32.Subsystem) \|\|
	!read(&oh32.DllCharacteristics) \|\|
	!read(&oh32.SizeOfStackReserve) \|\|
	!read(&oh32.SizeOfStackCommit) \|\|
	!read(&oh32.SizeOfHeapReserve) \|\|
	!read(&oh32.SizeOfHeapCommit) \|\|
	!read(&oh32.LoaderFlags) \|\|
	!read(&oh32.NumberOfRvaAndSizes) {
	return nil, fmt.Errorf("failure to read PE32 optional header: %v", err)
	}

	dd, err := readDataDirectories(r, sz-uint16(oh32MinSz), oh32.NumberOfRvaAndSizes)
	if err != nil {
	return nil, err
	}

	copy(oh32.DataDirectory[:], dd)

	return &oh32, nil
	case 0x20b: // PE32+
	var (
	oh64 OptionalHeader64
	// There can be 0 or more data directories. So the minimum size of optional
	// header is calculated by subtracting oh64.DataDirectory size from oh64 size.
	oh64MinSz = binary.Size(oh64) - binary.Size(oh64.DataDirectory)
	)

	if sz < uint16(oh64MinSz) {
	return nil, fmt.Errorf("optional header size(%d) is less minimum size (%d) for PE32+ optional header", sz, oh64MinSz)
	}

	// Init oh64 fields
	oh64.Magic = ohMagic
	if !read(&oh64.MajorLinkerVersion) \|\|
	!read(&oh64.MinorLinkerVersion) \|\|
	!read(&oh64.SizeOfCode) \|\|
	!read(&oh64.SizeOfInitializedData) \|\|
	!read(&oh64.SizeOfUninitializedData) \|\|
	!read(&oh64.AddressOfEntryPoint) \|\|
	!read(&oh64.BaseOfCode) \|\|
	!read(&oh64.ImageBase) \|\|
	!read(&oh64.SectionAlignment) \|\|
	!read(&oh64.FileAlignment) \|\|
	!read(&oh64.MajorOperatingSystemVersion) \|\|
	!read(&oh64.MinorOperatingSystemVersion) \|\|
	!read(&oh64.MajorImageVersion) \|\|
	!read(&oh64.MinorImageVersion) \|\|
	!read(&oh64.MajorSubsystemVersion) \|\|
	!read(&oh64.MinorSubsystemVersion) \|\|
	!read(&oh64.Win32VersionValue) \|\|
	!read(&oh64.SizeOfImage) \|\|
	!read(&oh64.SizeOfHeaders) \|\|
	!read(&oh64.CheckSum) \|\|
	!read(&oh64.Subsystem) \|\|
	!read(&oh64.DllCharacteristics) \|\|
	!read(&oh64.SizeOfStackReserve) \|\|
	!read(&oh64.SizeOfStackCommit) \|\|
	!read(&oh64.SizeOfHeapReserve) \|\|
	!read(&oh64.SizeOfHeapCommit) \|\|
	!read(&oh64.LoaderFlags) \|\|
	!read(&oh64.NumberOfRvaAndSizes) {
	return nil, fmt.Errorf("failure to read PE32+ optional header: %v", err)
	}

	dd, err := readDataDirectories(r, sz-uint16(oh64MinSz), oh64.NumberOfRvaAndSizes)
	if err != nil {
	return nil, err
	}

	copy(oh64.DataDirectory[:], dd)

	return &oh64, nil
	default:
	return nil, fmt.Errorf("optional header has unexpected Magic of 0x%x", ohMagic)
	}
	}

	// readDataDirectories accepts a io.ReadSeeker pointing to data directories in the PE file,
	// its size and number of data directories as seen in optional header.
	// It parses the given size of bytes and returns given number of data directories.
	func readDataDirectories(r io.ReadSeeker, sz uint16, n uint32) ([]DataDirectory, error) {
	ddSz := binary.Size(DataDirectory{})
	if uint32(sz) != n*uint32(ddSz) {
	return nil, fmt.Errorf("size of data directories(%d) is inconsistent with number of data directories(%d)", sz, n)
	}

	dd := make([]DataDirectory, n)
	if err := binary.Read(r, binary.LittleEndian, dd); err != nil {
	return nil, fmt.Errorf("failure to read data directories: %v", err)
	}

	return dd, nil
	}