| // Copyright 2014 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 plan9obj implements access to Plan 9 a.out object files. | |
| package plan9obj | |
| import ( | |
| "encoding/binary" | |
| "errors" | |
| "fmt" | |
| "io" | |
| "os" | |
| ) | |
| // A FileHeader represents a Plan 9 a.out file header. | |
| type FileHeader struct { | |
| Magic uint32 | |
| Bss uint32 | |
| Entry uint64 | |
| PtrSize int | |
| LoadAddress uint64 | |
| HdrSize uint64 | |
| } | |
| // A File represents an open Plan 9 a.out file. | |
| type File struct { | |
| FileHeader | |
| Sections []*Section | |
| closer io.Closer | |
| } | |
| // A SectionHeader represents a single Plan 9 a.out section header. | |
| // This structure doesn't exist on-disk, but eases navigation | |
| // through the object file. | |
| type SectionHeader struct { | |
| Name string | |
| Size uint32 | |
| Offset uint32 | |
| } | |
| // A Section represents a single section in a Plan 9 a.out file. | |
| 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 | |
| } | |
| // Data reads and returns the contents of the Plan 9 a.out 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 Plan 9 a.out section. | |
| func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) } | |
| // A Symbol represents an entry in a Plan 9 a.out symbol table section. | |
| type Sym struct { | |
| Value uint64 | |
| Type rune | |
| Name string | |
| } | |
| /* | |
| * Plan 9 a.out reader | |
| */ | |
| // formatError is returned by some operations if the data does | |
| // not have the correct format for an object file. | |
| type formatError struct { | |
| off int | |
| 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 Plan 9 a.out 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 | |
| } | |
| func parseMagic(magic []byte) (uint32, error) { | |
| m := binary.BigEndian.Uint32(magic) | |
| switch m { | |
| case Magic386, MagicAMD64, MagicARM: | |
| return m, nil | |
| } | |
| return 0, &formatError{0, "bad magic number", magic} | |
| } | |
| // NewFile creates a new File for accessing a Plan 9 binary in an underlying reader. | |
| // The Plan 9 binary is expected to start at position 0 in the ReaderAt. | |
| func NewFile(r io.ReaderAt) (*File, error) { | |
| sr := io.NewSectionReader(r, 0, 1<<63-1) | |
| // Read and decode Plan 9 magic | |
| var magic [4]byte | |
| if _, err := r.ReadAt(magic[:], 0); err != nil { | |
| return nil, err | |
| } | |
| _, err := parseMagic(magic[:]) | |
| if err != nil { | |
| return nil, err | |
| } | |
| ph := new(prog) | |
| if err := binary.Read(sr, binary.BigEndian, ph); err != nil { | |
| return nil, err | |
| } | |
| f := &File{FileHeader: FileHeader{ | |
| Magic: ph.Magic, | |
| Bss: ph.Bss, | |
| Entry: uint64(ph.Entry), | |
| PtrSize: 4, | |
| LoadAddress: 0x1000, | |
| HdrSize: 4 * 8, | |
| }} | |
| if ph.Magic&Magic64 != 0 { | |
| if err := binary.Read(sr, binary.BigEndian, &f.Entry); err != nil { | |
| return nil, err | |
| } | |
| f.PtrSize = 8 | |
| f.LoadAddress = 0x200000 | |
| f.HdrSize += 8 | |
| } | |
| var sects = []struct { | |
| name string | |
| size uint32 | |
| }{ | |
| {"text", ph.Text}, | |
| {"data", ph.Data}, | |
| {"syms", ph.Syms}, | |
| {"spsz", ph.Spsz}, | |
| {"pcsz", ph.Pcsz}, | |
| } | |
| f.Sections = make([]*Section, 5) | |
| off := uint32(f.HdrSize) | |
| for i, sect := range sects { | |
| s := new(Section) | |
| s.SectionHeader = SectionHeader{ | |
| Name: sect.name, | |
| Size: sect.size, | |
| Offset: off, | |
| } | |
| off += sect.size | |
| s.sr = io.NewSectionReader(r, int64(s.Offset), int64(s.Size)) | |
| s.ReaderAt = s.sr | |
| f.Sections[i] = s | |
| } | |
| return f, nil | |
| } | |
| func walksymtab(data []byte, ptrsz int, fn func(sym) error) error { | |
| var order binary.ByteOrder = binary.BigEndian | |
| var s sym | |
| p := data | |
| for len(p) >= 4 { | |
| // Symbol type, value. | |
| if len(p) < ptrsz { | |
| return &formatError{len(data), "unexpected EOF", nil} | |
| } | |
| // fixed-width value | |
| if ptrsz == 8 { | |
| s.value = order.Uint64(p[0:8]) | |
| p = p[8:] | |
| } else { | |
| s.value = uint64(order.Uint32(p[0:4])) | |
| p = p[4:] | |
| } | |
| var typ byte | |
| typ = p[0] & 0x7F | |
| s.typ = typ | |
| p = p[1:] | |
| // Name. | |
| var i int | |
| var nnul int | |
| for i = 0; i < len(p); i++ { | |
| if p[i] == 0 { | |
| nnul = 1 | |
| break | |
| } | |
| } | |
| switch typ { | |
| case 'z', 'Z': | |
| p = p[i+nnul:] | |
| for i = 0; i+2 <= len(p); i += 2 { | |
| if p[i] == 0 && p[i+1] == 0 { | |
| nnul = 2 | |
| break | |
| } | |
| } | |
| } | |
| if len(p) < i+nnul { | |
| return &formatError{len(data), "unexpected EOF", nil} | |
| } | |
| s.name = p[0:i] | |
| i += nnul | |
| p = p[i:] | |
| fn(s) | |
| } | |
| return nil | |
| } | |
| // NewTable decodes the Go symbol table in data, | |
| // returning an in-memory representation. | |
| func newTable(symtab []byte, ptrsz int) ([]Sym, error) { | |
| var n int | |
| err := walksymtab(symtab, ptrsz, func(s sym) error { | |
| n++ | |
| return nil | |
| }) | |
| if err != nil { | |
| return nil, err | |
| } | |
| fname := make(map[uint16]string) | |
| syms := make([]Sym, 0, n) | |
| err = walksymtab(symtab, ptrsz, func(s sym) error { | |
| n := len(syms) | |
| syms = syms[0 : n+1] | |
| ts := &syms[n] | |
| ts.Type = rune(s.typ) | |
| ts.Value = s.value | |
| switch s.typ { | |
| default: | |
| ts.Name = string(s.name[:]) | |
| case 'z', 'Z': | |
| for i := 0; i < len(s.name); i += 2 { | |
| eltIdx := binary.BigEndian.Uint16(s.name[i : i+2]) | |
| elt, ok := fname[eltIdx] | |
| if !ok { | |
| return &formatError{-1, "bad filename code", eltIdx} | |
| } | |
| if n := len(ts.Name); n > 0 && ts.Name[n-1] != '/' { | |
| ts.Name += "/" | |
| } | |
| ts.Name += elt | |
| } | |
| } | |
| switch s.typ { | |
| case 'f': | |
| fname[uint16(s.value)] = ts.Name | |
| } | |
| return nil | |
| }) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return syms, nil | |
| } | |
| // Symbols returns the symbol table for f. | |
| func (f *File) Symbols() ([]Sym, error) { | |
| symtabSection := f.Section("syms") | |
| if symtabSection == nil { | |
| return nil, errors.New("no symbol section") | |
| } | |
| symtab, err := symtabSection.Data() | |
| if err != nil { | |
| return nil, errors.New("cannot load symbol section") | |
| } | |
| return newTable(symtab, f.PtrSize) | |
| } | |
| // Section returns a 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 | |
| } |