URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [debug/] [pe/] [file.go] - Blame information for rev 747

Details | Compare with Previous | View Log


// 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
        Sections []*Section
 
        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 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)
        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
}
 
// 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' {
                var sign [4]byte
                r.ReadAt(sign[0:], int64(dosheader[0x3c]))
                if !(sign[0] == 'P' && sign[1] == 'E' && sign[2] == 0 && sign[3] == 0) {
                        return nil, errors.New("Invalid PE File Format.")
                }
                base = int64(dosheader[0x3c]) + 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.")
        }
        // get symbol string table
        sr.Seek(int64(f.FileHeader.PointerToSymbolTable+18*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+18*f.FileHeader.NumberOfSymbols)); err != nil {
                return nil, err
        }
        sr.Seek(base, os.SEEK_SET)
        binary.Read(sr, binary.LittleEndian, &f.FileHeader)
        sr.Seek(int64(f.FileHeader.SizeOfOptionalHeader), os.SEEK_CUR) //Skip OptionalHeader
        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:          uint32(sh.VirtualSize),
                        VirtualAddress:       uint32(sh.VirtualAddress),
                        Size:                 uint32(sh.SizeOfRawData),
                        Offset:               uint32(sh.PointerToRawData),
                        PointerToRelocations: uint32(sh.PointerToRelocations),
                        PointerToLineNumbers: uint32(sh.PointerToLineNumbers),
                        NumberOfRelocations:  uint16(sh.NumberOfRelocations),
                        NumberOfLineNumbers:  uint16(sh.NumberOfLineNumbers),
                        Characteristics:      uint32(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 required ones, and the debug/dwarf package
        // does not use the others, so don't bother loading them.
        var names = [...]string{"abbrev", "info", "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
                }
                dat[i] = b
        }
 
        abbrev, info, str := dat[0], dat[1], dat[2]
        return dwarf.New(abbrev, nil, nil, info, nil, 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
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [debug/] [pe/] [file.go] - Blame information for rev 747

Line No.	Rev	Author	Line
1	747	jeremybenn	`// Copyright 2009 The Go Authors. All rights reserved.`
2			`// Use of this source code is governed by a BSD-style`
3			`// license that can be found in the LICENSE file.`
4
5			`// Package pe implements access to PE (Microsoft Windows Portable Executable) files.`
6			`package pe`
7
8			`import (`
9			`"debug/dwarf"`
10			`"encoding/binary"`
11			`"errors"`
12			`"fmt"`
13			`"io"`
14			`"os"`
15			`"strconv"`
16			`)`
17
18			`// A File represents an open PE file.`
19			`type File struct {`
20			`FileHeader`
21			`Sections []*Section`
22
23			`closer io.Closer`
24			`}`
25
26			`type SectionHeader struct {`
27			`Name string`
28			`VirtualSize uint32`
29			`VirtualAddress uint32`
30			`Size uint32`
31			`Offset uint32`
32			`PointerToRelocations uint32`
33			`PointerToLineNumbers uint32`
34			`NumberOfRelocations uint16`
35			`NumberOfLineNumbers uint16`
36			`Characteristics uint32`
37			`}`
38
39			`type Section struct {`
40			`SectionHeader`
41
42			`// Embed ReaderAt for ReadAt method.`
43			`// Do not embed SectionReader directly`
44			`// to avoid having Read and Seek.`
45			`// If a client wants Read and Seek it must use`
46			`// Open() to avoid fighting over the seek offset`
47			`// with other clients.`
48			`io.ReaderAt`
49			`sr *io.SectionReader`
50			`}`
51
52			`type ImportDirectory struct {`
53			`OriginalFirstThunk uint32`
54			`TimeDateStamp uint32`
55			`ForwarderChain uint32`
56			`Name uint32`
57			`FirstThunk uint32`
58
59			`dll string`
60			`}`
61
62			`// Data reads and returns the contents of the PE section.`
63			`func (s *Section) Data() ([]byte, error) {`
64			`dat := make([]byte, s.sr.Size())`
65			`n, err := s.sr.ReadAt(dat, 0)`
66			`return dat[0:n], err`
67			`}`
68
69			`// Open returns a new ReadSeeker reading the PE section.`
70			`func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) }`
71
72			`type FormatError struct {`
73			`off int64`
74			`msg string`
75			`val interface{}`
76			`}`
77
78			`func (e *FormatError) Error() string {`
79			`msg := e.msg`
80			`if e.val != nil {`
81			`msg += fmt.Sprintf(" '%v'", e.val)`
82			`}`
83			`msg += fmt.Sprintf(" in record at byte %#x", e.off)`
84			`return msg`
85			`}`
86
87			`// Open opens the named file using os.Open and prepares it for use as a PE binary.`
88			`func Open(name string) (*File, error) {`
89			`f, err := os.Open(name)`
90			`if err != nil {`
91			`return nil, err`
92			`}`
93			`ff, err := NewFile(f)`
94			`if err != nil {`
95			`f.Close()`
96			`return nil, err`
97			`}`
98			`ff.closer = f`
99			`return ff, nil`
100			`}`
101
102			`// Close closes the File.`
103			`// If the File was created using NewFile directly instead of Open,`
104			`// Close has no effect.`
105			`func (f *File) Close() error {`
106			`var err error`
107			`if f.closer != nil {`
108			`err = f.closer.Close()`
109			`f.closer = nil`
110			`}`
111			`return err`
112			`}`
113
114			`// NewFile creates a new File for accessing a PE binary in an underlying reader.`
115			`func NewFile(r io.ReaderAt) (*File, error) {`
116			`f := new(File)`
117			`sr := io.NewSectionReader(r, 0, 1<<63-1)`
118
119			`var dosheader [96]byte`
120			`if _, err := r.ReadAt(dosheader[0:], 0); err != nil {`
121			`return nil, err`
122			`}`
123			`var base int64`
124			`if dosheader[0] == 'M' && dosheader[1] == 'Z' {`
125			`var sign [4]byte`
126			`r.ReadAt(sign[0:], int64(dosheader[0x3c]))`
127			`if !(sign[0] == 'P' && sign[1] == 'E' && sign[2] == 0 && sign[3] == 0) {`
128			`return nil, errors.New("Invalid PE File Format.")`
129			`}`
130			`base = int64(dosheader[0x3c]) + 4`
131			`} else {`
132			`base = int64(0)`
133			`}`
134			`sr.Seek(base, os.SEEK_SET)`
135			`if err := binary.Read(sr, binary.LittleEndian, &f.FileHeader); err != nil {`
136			`return nil, err`
137			`}`
138			`if f.FileHeader.Machine != IMAGE_FILE_MACHINE_UNKNOWN && f.FileHeader.Machine != IMAGE_FILE_MACHINE_AMD64 && f.FileHeader.Machine != IMAGE_FILE_MACHINE_I386 {`
139			`return nil, errors.New("Invalid PE File Format.")`
140			`}`
141			`// get symbol string table`
142			`sr.Seek(int64(f.FileHeader.PointerToSymbolTable+18*f.FileHeader.NumberOfSymbols), os.SEEK_SET)`
143			`var l uint32`
144			`if err := binary.Read(sr, binary.LittleEndian, &l); err != nil {`
145			`return nil, err`
146			`}`
147			`ss := make([]byte, l)`
148			`if _, err := r.ReadAt(ss, int64(f.FileHeader.PointerToSymbolTable+18*f.FileHeader.NumberOfSymbols)); err != nil {`
149			`return nil, err`
150			`}`
151			`sr.Seek(base, os.SEEK_SET)`
152			`binary.Read(sr, binary.LittleEndian, &f.FileHeader)`
153			`sr.Seek(int64(f.FileHeader.SizeOfOptionalHeader), os.SEEK_CUR) //Skip OptionalHeader`
154			`f.Sections = make([]*Section, f.FileHeader.NumberOfSections)`
155			`for i := 0; i < int(f.FileHeader.NumberOfSections); i++ {`
156			`sh := new(SectionHeader32)`
157			`if err := binary.Read(sr, binary.LittleEndian, sh); err != nil {`
158			`return nil, err`
159			`}`
160			`var name string`
161			`if sh.Name[0] == '\x2F' {`
162			`si, _ := strconv.Atoi(cstring(sh.Name[1:]))`
163			`name, _ = getString(ss, si)`
164			`} else {`
165			`name = cstring(sh.Name[0:])`
166			`}`
167			`s := new(Section)`
168			`s.SectionHeader = SectionHeader{`
169			`Name: name,`
170			`VirtualSize: uint32(sh.VirtualSize),`
171			`VirtualAddress: uint32(sh.VirtualAddress),`
172			`Size: uint32(sh.SizeOfRawData),`
173			`Offset: uint32(sh.PointerToRawData),`
174			`PointerToRelocations: uint32(sh.PointerToRelocations),`
175			`PointerToLineNumbers: uint32(sh.PointerToLineNumbers),`
176			`NumberOfRelocations: uint16(sh.NumberOfRelocations),`
177			`NumberOfLineNumbers: uint16(sh.NumberOfLineNumbers),`
178			`Characteristics: uint32(sh.Characteristics),`
179			`}`
180			`s.sr = io.NewSectionReader(r, int64(s.SectionHeader.Offset), int64(s.SectionHeader.Size))`
181			`s.ReaderAt = s.sr`
182			`f.Sections[i] = s`
183			`}`
184			`return f, nil`
185			`}`
186
187			`func cstring(b []byte) string {`
188			`var i int`
189			`for i = 0; i < len(b) && b[i] != 0; i++ {`
190			`}`
191			`return string(b[0:i])`
192			`}`
193
194			`// getString extracts a string from symbol string table.`
195			`func getString(section []byte, start int) (string, bool) {`
196			`if start < 0 \|\| start >= len(section) {`
197			`return "", false`
198			`}`
199
200			`for end := start; end < len(section); end++ {`
201			`if section[end] == 0 {`
202			`return string(section[start:end]), true`
203			`}`
204			`}`
205			`return "", false`
206			`}`
207
208			`// Section returns the first section with the given name, or nil if no such`
209			`// section exists.`
210			`func (f File) Section(name string) Section {`
211			`for _, s := range f.Sections {`
212			`if s.Name == name {`
213			`return s`
214			`}`
215			`}`
216			`return nil`
217			`}`
218
219			`func (f File) DWARF() (dwarf.Data, error) {`
220			`// There are many other DWARF sections, but these`
221			`// are the required ones, and the debug/dwarf package`
222			`// does not use the others, so don't bother loading them.`
223			`var names = [...]string{"abbrev", "info", "str"}`
224			`var dat [len(names)][]byte`
225			`for i, name := range names {`
226			`name = ".debug_" + name`
227			`s := f.Section(name)`
228			`if s == nil {`
229			`continue`
230			`}`
231			`b, err := s.Data()`
232			`if err != nil && uint32(len(b)) < s.Size {`
233			`return nil, err`
234			`}`
235			`dat[i] = b`
236			`}`
237
238			`abbrev, info, str := dat[0], dat[1], dat[2]`
239			`return dwarf.New(abbrev, nil, nil, info, nil, nil, nil, str)`
240			`}`
241
242			`// ImportedSymbols returns the names of all symbols`
243			`// referred to by the binary f that are expected to be`
244			`// satisfied by other libraries at dynamic load time.`
245			`// It does not return weak symbols.`
246			`func (f *File) ImportedSymbols() ([]string, error) {`
247			`pe64 := f.Machine == IMAGE_FILE_MACHINE_AMD64`
248			`ds := f.Section(".idata")`
249			`if ds == nil {`
250			`// not dynamic, so no libraries`
251			`return nil, nil`
252			`}`
253			`d, err := ds.Data()`
254			`if err != nil {`
255			`return nil, err`
256			`}`
257			`var ida []ImportDirectory`
258			`for len(d) > 0 {`
259			`var dt ImportDirectory`
260			`dt.OriginalFirstThunk = binary.LittleEndian.Uint32(d[0:4])`
261			`dt.Name = binary.LittleEndian.Uint32(d[12:16])`
262			`dt.FirstThunk = binary.LittleEndian.Uint32(d[16:20])`
263			`d = d[20:]`
264			`if dt.OriginalFirstThunk == 0 {`
265			`break`
266			`}`
267			`ida = append(ida, dt)`
268			`}`
269			`names, _ := ds.Data()`
270			`var all []string`
271			`for _, dt := range ida {`
272			`dt.dll, _ = getString(names, int(dt.Name-ds.VirtualAddress))`
273			`d, _ = ds.Data()`
274			`// seek to OriginalFirstThunk`
275			`d = d[dt.OriginalFirstThunk-ds.VirtualAddress:]`
276			`for len(d) > 0 {`
277			`if pe64 { // 64bit`
278			`va := binary.LittleEndian.Uint64(d[0:8])`
279			`d = d[8:]`
280			`if va == 0 {`
281			`break`
282			`}`
283			`if va&0x8000000000000000 > 0 { // is Ordinal`
284			`// TODO add dynimport ordinal support.`
285			`} else {`
286			`fn, _ := getString(names, int(uint32(va)-ds.VirtualAddress+2))`
287			`all = append(all, fn+":"+dt.dll)`
288			`}`
289			`} else { // 32bit`
290			`va := binary.LittleEndian.Uint32(d[0:4])`
291			`d = d[4:]`
292			`if va == 0 {`
293			`break`
294			`}`
295			`if va&0x80000000 > 0 { // is Ordinal`
296			`// TODO add dynimport ordinal support.`
297			`//ord := va&0x0000FFFF`
298			`} else {`
299			`fn, _ := getString(names, int(va-ds.VirtualAddress+2))`
300			`all = append(all, fn+":"+dt.dll)`
301			`}`
302			`}`
303			`}`
304			`}`
305
306			`return all, nil`
307			`}`
308
309			`// ImportedLibraries returns the names of all libraries`
310			`// referred to by the binary f that are expected to be`
311			`// linked with the binary at dynamic link time.`
312			`func (f *File) ImportedLibraries() ([]string, error) {`
313			`// TODO`
314			`// cgo -dynimport don't use this for windows PE, so just return.`
315			`return nil, nil`
316			`}`