third_party/gofrontend/libgo/go/debug/pe/file.go - llvm-project/llgo - 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 (
 	"debug/dwarf"
 	"encoding/binary"
 	"errors"
 	"fmt"
 	"io"
 	"os"
 	"strconv"
 )

 // A File represents an open PE file.
 type File struct {
 	FileHeader
 	OptionalHeader interface{} // of type *OptionalHeader32 or *OptionalHeader64
 	Sections       []*Section
 	Symbols        []*Symbol

 	closer io.Closer
 }

 type SectionHeader struct {
 	Name                 string
 	VirtualSize          uint32
 	VirtualAddress       uint32
 	Size                 uint32
 	Offset               uint32
 	PointerToRelocations uint32
 	PointerToLineNumbers uint32
 	NumberOfRelocations  uint16
 	NumberOfLineNumbers  uint16
 	Characteristics      uint32
 }

 type Section struct {
 	SectionHeader

 	// Embed ReaderAt for ReadAt method.
 	// Do not embed SectionReader directly
 	// to avoid having Read and Seek.
 	// If a client wants Read and Seek it must use
 	// Open() to avoid fighting over the seek offset
 	// with other clients.
 	io.ReaderAt
 	sr *io.SectionReader
 }

 type Symbol struct {
 	Name          string
 	Value         uint32
 	SectionNumber int16
 	Type          uint16
 	StorageClass  uint8
 }

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

 	dll string
 }

 // Data reads and returns the contents of the PE section.
 func (s *Section) Data() ([]byte, error) {
 	dat := make([]byte, s.sr.Size())
 	n, err := s.sr.ReadAt(dat, 0)
 	if n == len(dat) {
 		err = nil
 	}
 	return dat[0:n], err
 }

 // Open returns a new ReadSeeker reading the PE section.
 func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) }

 type FormatError struct {
 	off int64
 	msg string
 	val interface{}
 }

 func (e *FormatError) Error() string {
 	msg := e.msg
 	if e.val != nil {
 		msg += fmt.Sprintf(" '%v'", e.val)
 	}
 	msg += fmt.Sprintf(" in record at byte %#x", e.off)
 	return msg
 }

 // 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
 }

 var (
 	sizeofOptionalHeader32 = uint16(binary.Size(OptionalHeader32{}))
 	sizeofOptionalHeader64 = uint16(binary.Size(OptionalHeader64{}))
 )

 // 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, errors.New("Invalid PE File Format.")
 		}
 		base = signoff + 4
 	} else {
 		base = int64(0)
 	}
 	sr.Seek(base, os.SEEK_SET)
 	if err := binary.Read(sr, binary.LittleEndian, &f.FileHeader); err != nil {
 		return nil, err
 	}
 	if f.FileHeader.Machine != IMAGE_FILE_MACHINE_UNKNOWN && f.FileHeader.Machine != IMAGE_FILE_MACHINE_AMD64 && f.FileHeader.Machine != IMAGE_FILE_MACHINE_I386 {
 		return nil, errors.New("Invalid PE File Format.")
 	}

 	var ss []byte
 	if f.FileHeader.NumberOfSymbols > 0 {
 		// Get COFF string table, which is located at the end of the COFF symbol table.
 		sr.Seek(int64(f.FileHeader.PointerToSymbolTable+COFFSymbolSize*f.FileHeader.NumberOfSymbols), os.SEEK_SET)
 		var l uint32
 		if err := binary.Read(sr, binary.LittleEndian, &l); err != nil {
 			return nil, err
 		}
 		ss = make([]byte, l)
 		if _, err := r.ReadAt(ss, int64(f.FileHeader.PointerToSymbolTable+COFFSymbolSize*f.FileHeader.NumberOfSymbols)); err != nil {
 			return nil, err
 		}

 		// Process COFF symbol table.
 		sr.Seek(int64(f.FileHeader.PointerToSymbolTable), os.SEEK_SET)
 		aux := uint8(0)
 		for i := 0; i < int(f.FileHeader.NumberOfSymbols); i++ {
 			cs := new(COFFSymbol)
 			if err := binary.Read(sr, binary.LittleEndian, cs); err != nil {
 				return nil, err
 			}
 			if aux > 0 {
 				aux--
 				continue
 			}
 			var name string
 			if cs.Name[0] == 0 && cs.Name[1] == 0 && cs.Name[2] == 0 && cs.Name[3] == 0 {
 				si := int(binary.LittleEndian.Uint32(cs.Name[4:]))
 				name, _ = getString(ss, si)
 			} else {
 				name = cstring(cs.Name[:])
 			}
 			aux = cs.NumberOfAuxSymbols
 			s := &Symbol{
 				Name:          name,
 				Value:         cs.Value,
 				SectionNumber: cs.SectionNumber,
 				Type:          cs.Type,
 				StorageClass:  cs.StorageClass,
 			}
 			f.Symbols = append(f.Symbols, s)
 		}
 	}

 	// Read optional header.
 	sr.Seek(base, os.SEEK_SET)
 	if err := binary.Read(sr, binary.LittleEndian, &f.FileHeader); err != nil {
 		return nil, err
 	}
 	var oh32 OptionalHeader32
 	var oh64 OptionalHeader64
 	switch f.FileHeader.SizeOfOptionalHeader {
 	case sizeofOptionalHeader32:
 		if err := binary.Read(sr, binary.LittleEndian, &oh32); err != nil {
 			return nil, err
 		}
 		if oh32.Magic != 0x10b { // PE32
 			return nil, fmt.Errorf("pe32 optional header has unexpected Magic of 0x%x", oh32.Magic)
 		}
 		f.OptionalHeader = &oh32
 	case sizeofOptionalHeader64:
 		if err := binary.Read(sr, binary.LittleEndian, &oh64); err != nil {
 			return nil, err
 		}
 		if oh64.Magic != 0x20b { // PE32+
 			return nil, fmt.Errorf("pe32+ optional header has unexpected Magic of 0x%x", oh64.Magic)
 		}
 		f.OptionalHeader = &oh64
 	}

 	// 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
 		}
 		var name string
 		if sh.Name[0] == '\x2F' {
 			si, _ := strconv.Atoi(cstring(sh.Name[1:]))
 			name, _ = getString(ss, si)
 		} else {
 			name = cstring(sh.Name[0:])
 		}
 		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,
 		}
 		s.sr = io.NewSectionReader(r, int64(s.SectionHeader.Offset), int64(s.SectionHeader.Size))
 		s.ReaderAt = s.sr
 		f.Sections[i] = s
 	}
 	return f, nil
 }

 func cstring(b []byte) string {
 	var i int
 	for i = 0; i < len(b) && b[i] != 0; i++ {
 	}
 	return string(b[0:i])
 }

 // 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) {
 	// There are many other DWARF sections, but these
 	// are the ones the debug/dwarf package uses.
 	// Don't bother loading others.
 	var names = [...]string{"abbrev", "info", "line", "str"}
 	var dat [len(names)][]byte
 	for i, name := range names {
 		name = ".debug_" + name
 		s := f.Section(name)
 		if s == nil {
 			continue
 		}
 		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]
 		}
 		dat[i] = b
 	}

 	abbrev, info, line, str := dat[0], dat[1], dat[2], dat[3]
 	return dwarf.New(abbrev, nil, nil, info, line, nil, nil, str)
 }

 // 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) {
 	pe64 := f.Machine == IMAGE_FILE_MACHINE_AMD64
 	ds := f.Section(".idata")
 	if ds == nil {
 		// not dynamic, so no libraries
 		return nil, nil
 	}
 	d, err := ds.Data()
 	if err != nil {
 		return nil, err
 	}
 	var ida []ImportDirectory
 	for len(d) > 0 {
 		var dt ImportDirectory
 		dt.OriginalFirstThunk = binary.LittleEndian.Uint32(d[0:4])
 		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)
 	}
 	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
 }
	// 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 (
	"debug/dwarf"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"os"
	"strconv"
	)

	// A File represents an open PE file.
	type File struct {
	FileHeader
	OptionalHeader interface{} // of type OptionalHeader32 or OptionalHeader64
	Sections []*Section
	Symbols []*Symbol

	closer io.Closer
	}

	type SectionHeader struct {
	Name string
	VirtualSize uint32
	VirtualAddress uint32
	Size uint32
	Offset uint32
	PointerToRelocations uint32
	PointerToLineNumbers uint32
	NumberOfRelocations uint16
	NumberOfLineNumbers uint16
	Characteristics uint32
	}

	type Section struct {
	SectionHeader

	// Embed ReaderAt for ReadAt method.
	// Do not embed SectionReader directly
	// to avoid having Read and Seek.
	// If a client wants Read and Seek it must use
	// Open() to avoid fighting over the seek offset
	// with other clients.
	io.ReaderAt
	sr *io.SectionReader
	}

	type Symbol struct {
	Name string
	Value uint32
	SectionNumber int16
	Type uint16
	StorageClass uint8
	}

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

	dll string
	}

	// Data reads and returns the contents of the PE section.
	func (s *Section) Data() ([]byte, error) {
	dat := make([]byte, s.sr.Size())
	n, err := s.sr.ReadAt(dat, 0)
	if n == len(dat) {
	err = nil
	}
	return dat[0:n], err
	}

	// Open returns a new ReadSeeker reading the PE section.
	func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) }

	type FormatError struct {
	off int64
	msg string
	val interface{}
	}

	func (e *FormatError) Error() string {
	msg := e.msg
	if e.val != nil {
	msg += fmt.Sprintf(" '%v'", e.val)
	}
	msg += fmt.Sprintf(" in record at byte %#x", e.off)
	return msg
	}

	// 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
	}

	var (
	sizeofOptionalHeader32 = uint16(binary.Size(OptionalHeader32{}))
	sizeofOptionalHeader64 = uint16(binary.Size(OptionalHeader64{}))
	)

	// 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, errors.New("Invalid PE File Format.")
	}
	base = signoff + 4
	} else {
	base = int64(0)
	}
	sr.Seek(base, os.SEEK_SET)
	if err := binary.Read(sr, binary.LittleEndian, &f.FileHeader); err != nil {
	return nil, err
	}
	if f.FileHeader.Machine != IMAGE_FILE_MACHINE_UNKNOWN && f.FileHeader.Machine != IMAGE_FILE_MACHINE_AMD64 && f.FileHeader.Machine != IMAGE_FILE_MACHINE_I386 {
	return nil, errors.New("Invalid PE File Format.")
	}

	var ss []byte
	if f.FileHeader.NumberOfSymbols > 0 {
	// Get COFF string table, which is located at the end of the COFF symbol table.
	sr.Seek(int64(f.FileHeader.PointerToSymbolTable+COFFSymbolSize*f.FileHeader.NumberOfSymbols), os.SEEK_SET)
	var l uint32
	if err := binary.Read(sr, binary.LittleEndian, &l); err != nil {
	return nil, err
	}
	ss = make([]byte, l)
	if _, err := r.ReadAt(ss, int64(f.FileHeader.PointerToSymbolTable+COFFSymbolSize*f.FileHeader.NumberOfSymbols)); err != nil {
	return nil, err
	}

	// Process COFF symbol table.
	sr.Seek(int64(f.FileHeader.PointerToSymbolTable), os.SEEK_SET)
	aux := uint8(0)
	for i := 0; i < int(f.FileHeader.NumberOfSymbols); i++ {
	cs := new(COFFSymbol)
	if err := binary.Read(sr, binary.LittleEndian, cs); err != nil {
	return nil, err
	}
	if aux > 0 {
	aux--
	continue
	}
	var name string
	if cs.Name[0] == 0 && cs.Name[1] == 0 && cs.Name[2] == 0 && cs.Name[3] == 0 {
	si := int(binary.LittleEndian.Uint32(cs.Name[4:]))
	name, _ = getString(ss, si)
	} else {
	name = cstring(cs.Name[:])
	}
	aux = cs.NumberOfAuxSymbols
	s := &Symbol{
	Name: name,
	Value: cs.Value,
	SectionNumber: cs.SectionNumber,
	Type: cs.Type,
	StorageClass: cs.StorageClass,
	}
	f.Symbols = append(f.Symbols, s)
	}
	}

	// Read optional header.
	sr.Seek(base, os.SEEK_SET)
	if err := binary.Read(sr, binary.LittleEndian, &f.FileHeader); err != nil {
	return nil, err
	}
	var oh32 OptionalHeader32
	var oh64 OptionalHeader64
	switch f.FileHeader.SizeOfOptionalHeader {
	case sizeofOptionalHeader32:
	if err := binary.Read(sr, binary.LittleEndian, &oh32); err != nil {
	return nil, err
	}
	if oh32.Magic != 0x10b { // PE32
	return nil, fmt.Errorf("pe32 optional header has unexpected Magic of 0x%x", oh32.Magic)
	}
	f.OptionalHeader = &oh32
	case sizeofOptionalHeader64:
	if err := binary.Read(sr, binary.LittleEndian, &oh64); err != nil {
	return nil, err
	}
	if oh64.Magic != 0x20b { // PE32+
	return nil, fmt.Errorf("pe32+ optional header has unexpected Magic of 0x%x", oh64.Magic)
	}
	f.OptionalHeader = &oh64
	}

	// 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
	}
	var name string
	if sh.Name[0] == '\x2F' {
	si, _ := strconv.Atoi(cstring(sh.Name[1:]))
	name, _ = getString(ss, si)
	} else {
	name = cstring(sh.Name[0:])
	}
	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,
	}
	s.sr = io.NewSectionReader(r, int64(s.SectionHeader.Offset), int64(s.SectionHeader.Size))
	s.ReaderAt = s.sr
	f.Sections[i] = s
	}
	return f, nil
	}

	func cstring(b []byte) string {
	var i int
	for i = 0; i < len(b) && b[i] != 0; i++ {
	}
	return string(b[0:i])
	}

	// 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) {
	// There are many other DWARF sections, but these
	// are the ones the debug/dwarf package uses.
	// Don't bother loading others.
	var names = [...]string{"abbrev", "info", "line", "str"}
	var dat [len(names)][]byte
	for i, name := range names {
	name = ".debug_" + name
	s := f.Section(name)
	if s == nil {
	continue
	}
	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]
	}
	dat[i] = b
	}

	abbrev, info, line, str := dat[0], dat[1], dat[2], dat[3]
	return dwarf.New(abbrev, nil, nil, info, line, nil, nil, str)
	}

	// 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) {
	pe64 := f.Machine == IMAGE_FILE_MACHINE_AMD64
	ds := f.Section(".idata")
	if ds == nil {
	// not dynamic, so no libraries
	return nil, nil
	}
	d, err := ds.Data()
	if err != nil {
	return nil, err
	}
	var ida []ImportDirectory
	for len(d) > 0 {
	var dt ImportDirectory
	dt.OriginalFirstThunk = binary.LittleEndian.Uint32(d[0:4])
	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)
	}
	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
	}