Source file src/debug/plan9obj/file.go

Documentation: debug/plan9obj

     1  // Copyright 2014 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 plan9obj implements access to Plan 9 a.out object files.
     6  package plan9obj
     7  
     8  import (
     9  	"encoding/binary"
    10  	"errors"
    11  	"fmt"
    12  	"io"
    13  	"os"
    14  )
    15  
    16  // A FileHeader represents a Plan 9 a.out file header.
    17  type FileHeader struct {
    18  	Magic       uint32
    19  	Bss         uint32
    20  	Entry       uint64
    21  	PtrSize     int
    22  	LoadAddress uint64
    23  	HdrSize     uint64
    24  }
    25  
    26  // A File represents an open Plan 9 a.out file.
    27  type File struct {
    28  	FileHeader
    29  	Sections []*Section
    30  	closer   io.Closer
    31  }
    32  
    33  // A SectionHeader represents a single Plan 9 a.out section header.
    34  // This structure doesn't exist on-disk, but eases navigation
    35  // through the object file.
    36  type SectionHeader struct {
    37  	Name   string
    38  	Size   uint32
    39  	Offset uint32
    40  }
    41  
    42  // A Section represents a single section in a Plan 9 a.out file.
    43  type Section struct {
    44  	SectionHeader
    45  
    46  	// Embed ReaderAt for ReadAt method.
    47  	// Do not embed SectionReader directly
    48  	// to avoid having Read and Seek.
    49  	// If a client wants Read and Seek it must use
    50  	// Open() to avoid fighting over the seek offset
    51  	// with other clients.
    52  	io.ReaderAt
    53  	sr *io.SectionReader
    54  }
    55  
    56  // Data reads and returns the contents of the Plan 9 a.out section.
    57  func (s *Section) Data() ([]byte, error) {
    58  	dat := make([]byte, s.sr.Size())
    59  	n, err := s.sr.ReadAt(dat, 0)
    60  	if n == len(dat) {
    61  		err = nil
    62  	}
    63  	return dat[0:n], err
    64  }
    65  
    66  // Open returns a new ReadSeeker reading the Plan 9 a.out section.
    67  func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) }
    68  
    69  // A Symbol represents an entry in a Plan 9 a.out symbol table section.
    70  type Sym struct {
    71  	Value uint64
    72  	Type  rune
    73  	Name  string
    74  }
    75  
    76  /*
    77   * Plan 9 a.out reader
    78   */
    79  
    80  // formatError is returned by some operations if the data does
    81  // not have the correct format for an object file.
    82  type formatError struct {
    83  	off int
    84  	msg string
    85  	val interface{}
    86  }
    87  
    88  func (e *formatError) Error() string {
    89  	msg := e.msg
    90  	if e.val != nil {
    91  		msg += fmt.Sprintf(" '%v'", e.val)
    92  	}
    93  	msg += fmt.Sprintf(" in record at byte %#x", e.off)
    94  	return msg
    95  }
    96  
    97  // Open opens the named file using os.Open and prepares it for use as a Plan 9 a.out binary.
    98  func Open(name string) (*File, error) {
    99  	f, err := os.Open(name)
   100  	if err != nil {
   101  		return nil, err
   102  	}
   103  	ff, err := NewFile(f)
   104  	if err != nil {
   105  		f.Close()
   106  		return nil, err
   107  	}
   108  	ff.closer = f
   109  	return ff, nil
   110  }
   111  
   112  // Close closes the File.
   113  // If the File was created using NewFile directly instead of Open,
   114  // Close has no effect.
   115  func (f *File) Close() error {
   116  	var err error
   117  	if f.closer != nil {
   118  		err = f.closer.Close()
   119  		f.closer = nil
   120  	}
   121  	return err
   122  }
   123  
   124  func parseMagic(magic []byte) (uint32, error) {
   125  	m := binary.BigEndian.Uint32(magic)
   126  	switch m {
   127  	case Magic386, MagicAMD64, MagicARM:
   128  		return m, nil
   129  	}
   130  	return 0, &formatError{0, "bad magic number", magic}
   131  }
   132  
   133  // NewFile creates a new File for accessing a Plan 9 binary in an underlying reader.
   134  // The Plan 9 binary is expected to start at position 0 in the ReaderAt.
   135  func NewFile(r io.ReaderAt) (*File, error) {
   136  	sr := io.NewSectionReader(r, 0, 1<<63-1)
   137  	// Read and decode Plan 9 magic
   138  	var magic [4]byte
   139  	if _, err := r.ReadAt(magic[:], 0); err != nil {
   140  		return nil, err
   141  	}
   142  	_, err := parseMagic(magic[:])
   143  	if err != nil {
   144  		return nil, err
   145  	}
   146  
   147  	ph := new(prog)
   148  	if err := binary.Read(sr, binary.BigEndian, ph); err != nil {
   149  		return nil, err
   150  	}
   151  
   152  	f := &File{FileHeader: FileHeader{
   153  		Magic:       ph.Magic,
   154  		Bss:         ph.Bss,
   155  		Entry:       uint64(ph.Entry),
   156  		PtrSize:     4,
   157  		LoadAddress: 0x1000,
   158  		HdrSize:     4 * 8,
   159  	}}
   160  
   161  	if ph.Magic&Magic64 != 0 {
   162  		if err := binary.Read(sr, binary.BigEndian, &f.Entry); err != nil {
   163  			return nil, err
   164  		}
   165  		f.PtrSize = 8
   166  		f.LoadAddress = 0x200000
   167  		f.HdrSize += 8
   168  	}
   169  
   170  	var sects = []struct {
   171  		name string
   172  		size uint32
   173  	}{
   174  		{"text", ph.Text},
   175  		{"data", ph.Data},
   176  		{"syms", ph.Syms},
   177  		{"spsz", ph.Spsz},
   178  		{"pcsz", ph.Pcsz},
   179  	}
   180  
   181  	f.Sections = make([]*Section, 5)
   182  
   183  	off := uint32(f.HdrSize)
   184  
   185  	for i, sect := range sects {
   186  		s := new(Section)
   187  		s.SectionHeader = SectionHeader{
   188  			Name:   sect.name,
   189  			Size:   sect.size,
   190  			Offset: off,
   191  		}
   192  		off += sect.size
   193  		s.sr = io.NewSectionReader(r, int64(s.Offset), int64(s.Size))
   194  		s.ReaderAt = s.sr
   195  		f.Sections[i] = s
   196  	}
   197  
   198  	return f, nil
   199  }
   200  
   201  func walksymtab(data []byte, ptrsz int, fn func(sym) error) error {
   202  	var order binary.ByteOrder = binary.BigEndian
   203  	var s sym
   204  	p := data
   205  	for len(p) >= 4 {
   206  		// Symbol type, value.
   207  		if len(p) < ptrsz {
   208  			return &formatError{len(data), "unexpected EOF", nil}
   209  		}
   210  		// fixed-width value
   211  		if ptrsz == 8 {
   212  			s.value = order.Uint64(p[0:8])
   213  			p = p[8:]
   214  		} else {
   215  			s.value = uint64(order.Uint32(p[0:4]))
   216  			p = p[4:]
   217  		}
   218  
   219  		var typ byte
   220  		typ = p[0] & 0x7F
   221  		s.typ = typ
   222  		p = p[1:]
   223  
   224  		// Name.
   225  		var i int
   226  		var nnul int
   227  		for i = 0; i < len(p); i++ {
   228  			if p[i] == 0 {
   229  				nnul = 1
   230  				break
   231  			}
   232  		}
   233  		switch typ {
   234  		case 'z', 'Z':
   235  			p = p[i+nnul:]
   236  			for i = 0; i+2 <= len(p); i += 2 {
   237  				if p[i] == 0 && p[i+1] == 0 {
   238  					nnul = 2
   239  					break
   240  				}
   241  			}
   242  		}
   243  		if len(p) < i+nnul {
   244  			return &formatError{len(data), "unexpected EOF", nil}
   245  		}
   246  		s.name = p[0:i]
   247  		i += nnul
   248  		p = p[i:]
   249  
   250  		fn(s)
   251  	}
   252  	return nil
   253  }
   254  
   255  // NewTable decodes the Go symbol table in data,
   256  // returning an in-memory representation.
   257  func newTable(symtab []byte, ptrsz int) ([]Sym, error) {
   258  	var n int
   259  	err := walksymtab(symtab, ptrsz, func(s sym) error {
   260  		n++
   261  		return nil
   262  	})
   263  	if err != nil {
   264  		return nil, err
   265  	}
   266  
   267  	fname := make(map[uint16]string)
   268  	syms := make([]Sym, 0, n)
   269  	err = walksymtab(symtab, ptrsz, func(s sym) error {
   270  		n := len(syms)
   271  		syms = syms[0 : n+1]
   272  		ts := &syms[n]
   273  		ts.Type = rune(s.typ)
   274  		ts.Value = s.value
   275  		switch s.typ {
   276  		default:
   277  			ts.Name = string(s.name)
   278  		case 'z', 'Z':
   279  			for i := 0; i < len(s.name); i += 2 {
   280  				eltIdx := binary.BigEndian.Uint16(s.name[i : i+2])
   281  				elt, ok := fname[eltIdx]
   282  				if !ok {
   283  					return &formatError{-1, "bad filename code", eltIdx}
   284  				}
   285  				if n := len(ts.Name); n > 0 && ts.Name[n-1] != '/' {
   286  					ts.Name += "/"
   287  				}
   288  				ts.Name += elt
   289  			}
   290  		}
   291  		switch s.typ {
   292  		case 'f':
   293  			fname[uint16(s.value)] = ts.Name
   294  		}
   295  		return nil
   296  	})
   297  	if err != nil {
   298  		return nil, err
   299  	}
   300  
   301  	return syms, nil
   302  }
   303  
   304  // Symbols returns the symbol table for f.
   305  func (f *File) Symbols() ([]Sym, error) {
   306  	symtabSection := f.Section("syms")
   307  	if symtabSection == nil {
   308  		return nil, errors.New("no symbol section")
   309  	}
   310  
   311  	symtab, err := symtabSection.Data()
   312  	if err != nil {
   313  		return nil, errors.New("cannot load symbol section")
   314  	}
   315  
   316  	return newTable(symtab, f.PtrSize)
   317  }
   318  
   319  // Section returns a section with the given name, or nil if no such
   320  // section exists.
   321  func (f *File) Section(name string) *Section {
   322  	for _, s := range f.Sections {
   323  		if s.Name == name {
   324  			return s
   325  		}
   326  	}
   327  	return nil
   328  }
   329  

View as plain text