1 files changed, 0 insertions, 325 deletions
diff --git a/src/pkg/debug/plan9obj/file.go b/src/pkg/debug/plan9obj/file.go
deleted file mode 100644
index 60a585719..000000000
--- a/src/pkg/debug/plan9obj/file.go
+++ /dev/null
@@ -1,325 +0,0 @@
-// 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
-}
-
-// 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,
-	}}
-
-	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
-		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(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
-}