diff --git a/src/pkg/debug/goobj/read.go b/src/cmd/nm/debug_goobj.go
similarity index 63%
rename from src/pkg/debug/goobj/read.go
rename to src/cmd/nm/debug_goobj.go
index c95fe1e..9a067e2 100644
--- a/src/pkg/debug/goobj/read.go
+++ b/src/cmd/nm/debug_goobj.go
@@ -1,3 +1,8 @@
+// DO NOT EDIT. Generated by code.google.com/p/rsc/cmd/bundle
+// bundle -p main -x goobj_ debug/goobj
+
+/* read.go */
+
 // Copyright 2013 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.
@@ -7,7 +12,8 @@
 // TODO(rsc): Decide where this package should live. (golang.org/issue/6932)
 // TODO(rsc): Decide the appropriate integer types for various fields.
 // TODO(rsc): Write tests. (File format still up in the air a little.)
-package goobj
+
+package main
 
 import (
 	"bufio"
@@ -20,7 +26,7 @@
 )
 
 // A SymKind describes the kind of memory represented by a symbol.
-type SymKind int
+type goobj_SymKind int
 
 // This list is taken from include/link.h.
 
@@ -28,108 +34,108 @@
 // TODO(rsc): Give idiomatic Go names.
 // TODO(rsc): Reduce the number of symbol types in the object files.
 const (
-	_ SymKind = iota
+	_ goobj_SymKind = iota
 
 	// readonly, executable
-	STEXT
-	SELFRXSECT
+	goobj_STEXT
+	goobj_SELFRXSECT
 
 	// readonly, non-executable
-	STYPE
-	SSTRING
-	SGOSTRING
-	SGOFUNC
-	SRODATA
-	SFUNCTAB
-	STYPELINK
-	SSYMTAB // TODO: move to unmapped section
-	SPCLNTAB
-	SELFROSECT
+	goobj_STYPE
+	goobj_SSTRING
+	goobj_SGOSTRING
+	goobj_SGOFUNC
+	goobj_SRODATA
+	goobj_SFUNCTAB
+	goobj_STYPELINK
+	goobj_SSYMTAB // TODO: move to unmapped section
+	goobj_SPCLNTAB
+	goobj_SELFROSECT
 
 	// writable, non-executable
-	SMACHOPLT
-	SELFSECT
-	SMACHO // Mach-O __nl_symbol_ptr
-	SMACHOGOT
-	SNOPTRDATA
-	SINITARR
-	SDATA
-	SWINDOWS
-	SBSS
-	SNOPTRBSS
-	STLSBSS
+	goobj_SMACHOPLT
+	goobj_SELFSECT
+	goobj_SMACHO // Mach-O __nl_symbol_ptr
+	goobj_SMACHOGOT
+	goobj_SNOPTRDATA
+	goobj_SINITARR
+	goobj_SDATA
+	goobj_SWINDOWS
+	goobj_SBSS
+	goobj_SNOPTRBSS
+	goobj_STLSBSS
 
 	// not mapped
-	SXREF
-	SMACHOSYMSTR
-	SMACHOSYMTAB
-	SMACHOINDIRECTPLT
-	SMACHOINDIRECTGOT
-	SFILE
-	SFILEPATH
-	SCONST
-	SDYNIMPORT
-	SHOSTOBJ
+	goobj_SXREF
+	goobj_SMACHOSYMSTR
+	goobj_SMACHOSYMTAB
+	goobj_SMACHOINDIRECTPLT
+	goobj_SMACHOINDIRECTGOT
+	goobj_SFILE
+	goobj_SFILEPATH
+	goobj_SCONST
+	goobj_SDYNIMPORT
+	goobj_SHOSTOBJ
 )
 
-var symKindStrings = []string{
-	SBSS:              "SBSS",
-	SCONST:            "SCONST",
-	SDATA:             "SDATA",
-	SDYNIMPORT:        "SDYNIMPORT",
-	SELFROSECT:        "SELFROSECT",
-	SELFRXSECT:        "SELFRXSECT",
-	SELFSECT:          "SELFSECT",
-	SFILE:             "SFILE",
-	SFILEPATH:         "SFILEPATH",
-	SFUNCTAB:          "SFUNCTAB",
-	SGOFUNC:           "SGOFUNC",
-	SGOSTRING:         "SGOSTRING",
-	SHOSTOBJ:          "SHOSTOBJ",
-	SINITARR:          "SINITARR",
-	SMACHO:            "SMACHO",
-	SMACHOGOT:         "SMACHOGOT",
-	SMACHOINDIRECTGOT: "SMACHOINDIRECTGOT",
-	SMACHOINDIRECTPLT: "SMACHOINDIRECTPLT",
-	SMACHOPLT:         "SMACHOPLT",
-	SMACHOSYMSTR:      "SMACHOSYMSTR",
-	SMACHOSYMTAB:      "SMACHOSYMTAB",
-	SNOPTRBSS:         "SNOPTRBSS",
-	SNOPTRDATA:        "SNOPTRDATA",
-	SPCLNTAB:          "SPCLNTAB",
-	SRODATA:           "SRODATA",
-	SSTRING:           "SSTRING",
-	SSYMTAB:           "SSYMTAB",
-	STEXT:             "STEXT",
-	STLSBSS:           "STLSBSS",
-	STYPE:             "STYPE",
-	STYPELINK:         "STYPELINK",
-	SWINDOWS:          "SWINDOWS",
-	SXREF:             "SXREF",
+var goobj_symKindStrings = []string{
+	goobj_SBSS:              "SBSS",
+	goobj_SCONST:            "SCONST",
+	goobj_SDATA:             "SDATA",
+	goobj_SDYNIMPORT:        "SDYNIMPORT",
+	goobj_SELFROSECT:        "SELFROSECT",
+	goobj_SELFRXSECT:        "SELFRXSECT",
+	goobj_SELFSECT:          "SELFSECT",
+	goobj_SFILE:             "SFILE",
+	goobj_SFILEPATH:         "SFILEPATH",
+	goobj_SFUNCTAB:          "SFUNCTAB",
+	goobj_SGOFUNC:           "SGOFUNC",
+	goobj_SGOSTRING:         "SGOSTRING",
+	goobj_SHOSTOBJ:          "SHOSTOBJ",
+	goobj_SINITARR:          "SINITARR",
+	goobj_SMACHO:            "SMACHO",
+	goobj_SMACHOGOT:         "SMACHOGOT",
+	goobj_SMACHOINDIRECTGOT: "SMACHOINDIRECTGOT",
+	goobj_SMACHOINDIRECTPLT: "SMACHOINDIRECTPLT",
+	goobj_SMACHOPLT:         "SMACHOPLT",
+	goobj_SMACHOSYMSTR:      "SMACHOSYMSTR",
+	goobj_SMACHOSYMTAB:      "SMACHOSYMTAB",
+	goobj_SNOPTRBSS:         "SNOPTRBSS",
+	goobj_SNOPTRDATA:        "SNOPTRDATA",
+	goobj_SPCLNTAB:          "SPCLNTAB",
+	goobj_SRODATA:           "SRODATA",
+	goobj_SSTRING:           "SSTRING",
+	goobj_SSYMTAB:           "SSYMTAB",
+	goobj_STEXT:             "STEXT",
+	goobj_STLSBSS:           "STLSBSS",
+	goobj_STYPE:             "STYPE",
+	goobj_STYPELINK:         "STYPELINK",
+	goobj_SWINDOWS:          "SWINDOWS",
+	goobj_SXREF:             "SXREF",
 }
 
-func (k SymKind) String() string {
-	if k < 0 || int(k) >= len(symKindStrings) {
+func (k goobj_SymKind) String() string {
+	if k < 0 || int(k) >= len(goobj_symKindStrings) {
 		return fmt.Sprintf("SymKind(%d)", k)
 	}
-	return symKindStrings[k]
+	return goobj_symKindStrings[k]
 }
 
 // A Sym is a named symbol in an object file.
-type Sym struct {
-	SymID         // symbol identifier (name and version)
-	Kind  SymKind // kind of symbol
-	DupOK bool    // are duplicate definitions okay?
-	Size  int     // size of corresponding data
-	Type  SymID   // symbol for Go type information
-	Data  Data    // memory image of symbol
-	Reloc []Reloc // relocations to apply to Data
-	Func  *Func   // additional data for functions
+type goobj_Sym struct {
+	goobj_SymID               // symbol identifier (name and version)
+	Kind        goobj_SymKind // kind of symbol
+	DupOK       bool          // are duplicate definitions okay?
+	Size        int           // size of corresponding data
+	Type        goobj_SymID   // symbol for Go type information
+	Data        goobj_Data    // memory image of symbol
+	Reloc       []goobj_Reloc // relocations to apply to Data
+	Func        *goobj_Func   // additional data for functions
 }
 
 // A SymID - the combination of Name and Version - uniquely identifies
 // a symbol within a package.
-type SymID struct {
+type goobj_SymID struct {
 	// Name is the name of a symbol.
 	Name string
 
@@ -141,7 +147,7 @@
 	Version int
 }
 
-func (s SymID) String() string {
+func (s goobj_SymID) String() string {
 	if s.Version == 0 {
 		return s.Name
 	}
@@ -151,20 +157,20 @@
 // A Data is a reference to data stored in an object file.
 // It records the offset and size of the data, so that a client can
 // read the data only if necessary.
-type Data struct {
+type goobj_Data struct {
 	Offset int64
 	Size   int64
 }
 
 // A Reloc describes a relocation applied to a memory image to refer
 // to an address within a particular symbol.
-type Reloc struct {
+type goobj_Reloc struct {
 	// The bytes at [Offset, Offset+Size) within the memory image
 	// should be updated to refer to the address Add bytes after the start
 	// of the symbol Sym.
 	Offset int
 	Size   int
-	Sym    SymID
+	Sym    goobj_SymID
 	Add    int
 
 	// The Type records the form of address expected in the bytes
@@ -175,7 +181,7 @@
 
 // A Var describes a variable in a function stack frame: a declared
 // local variable, an input argument, or an output result.
-type Var struct {
+type goobj_Var struct {
 	// The combination of Name, Kind, and Offset uniquely
 	// identifies a variable in a function stack frame.
 	// Using fewer of these - in particular, using only Name - does not.
@@ -183,57 +189,57 @@
 	Kind   int    // TODO(rsc): Define meaning.
 	Offset int    // Frame offset. TODO(rsc): Define meaning.
 
-	Type SymID // Go type for variable.
+	Type goobj_SymID // Go type for variable.
 }
 
 // Func contains additional per-symbol information specific to functions.
-type Func struct {
-	Args     int        // size in bytes of argument frame: inputs and outputs
-	Frame    int        // size in bytes of local variable frame
-	Leaf     bool       // function omits save of link register (ARM)
-	NoSplit  bool       // function omits stack split prologue
-	Var      []Var      // detail about local variables
-	PCSP     Data       // PC → SP offset map
-	PCFile   Data       // PC → file number map (index into File)
-	PCLine   Data       // PC → line number map
-	PCData   []Data     // PC → runtime support data map
-	FuncData []FuncData // non-PC-specific runtime support data
-	File     []string   // paths indexed by PCFile
+type goobj_Func struct {
+	Args     int              // size in bytes of argument frame: inputs and outputs
+	Frame    int              // size in bytes of local variable frame
+	Leaf     bool             // function omits save of link register (ARM)
+	NoSplit  bool             // function omits stack split prologue
+	Var      []goobj_Var      // detail about local variables
+	PCSP     goobj_Data       // PC → SP offset map
+	PCFile   goobj_Data       // PC → file number map (index into File)
+	PCLine   goobj_Data       // PC → line number map
+	PCData   []goobj_Data     // PC → runtime support data map
+	FuncData []goobj_FuncData // non-PC-specific runtime support data
+	File     []string         // paths indexed by PCFile
 }
 
 // TODO: Add PCData []byte and PCDataIter (similar to liblink).
 
 // A FuncData is a single function-specific data value.
-type FuncData struct {
-	Sym    SymID // symbol holding data
-	Offset int64 // offset into symbol for funcdata pointer
+type goobj_FuncData struct {
+	Sym    goobj_SymID // symbol holding data
+	Offset int64       // offset into symbol for funcdata pointer
 }
 
 // A Package is a parsed Go object file or archive defining a Go package.
-type Package struct {
-	ImportPath string   // import path denoting this package
-	Imports    []string // packages imported by this package
-	Syms       []*Sym   // symbols defined by this package
-	MaxVersion int      // maximum Version in any SymID in Syms
+type goobj_Package struct {
+	ImportPath string       // import path denoting this package
+	Imports    []string     // packages imported by this package
+	Syms       []*goobj_Sym // symbols defined by this package
+	MaxVersion int          // maximum Version in any SymID in Syms
 }
 
 var (
-	archiveHeader = []byte("!<arch>\n")
-	archiveMagic  = []byte("`\n")
-	goobjHeader   = []byte("go objec") // truncated to size of archiveHeader
+	goobj_archiveHeader = []byte("!<arch>\n")
+	goobj_archiveMagic  = []byte("`\n")
+	goobj_goobjHeader   = []byte("go objec") // truncated to size of archiveHeader
 
-	errCorruptArchive   = errors.New("corrupt archive")
-	errTruncatedArchive = errors.New("truncated archive")
-	errNotArchive       = errors.New("unrecognized archive format")
+	goobj_errCorruptArchive   = errors.New("corrupt archive")
+	goobj_errTruncatedArchive = errors.New("truncated archive")
+	goobj_errNotArchive       = errors.New("unrecognized archive format")
 
-	errCorruptObject   = errors.New("corrupt object file")
-	errTruncatedObject = errors.New("truncated object file")
-	errNotObject       = errors.New("unrecognized object file format")
+	goobj_errCorruptObject   = errors.New("corrupt object file")
+	goobj_errTruncatedObject = errors.New("truncated object file")
+	goobj_errNotObject       = errors.New("unrecognized object file format")
 )
 
 // An objReader is an object file reader.
-type objReader struct {
-	p         *Package
+type goobj_objReader struct {
+	p         *goobj_Package
 	b         *bufio.Reader
 	f         io.ReadSeeker
 	err       error
@@ -251,7 +257,7 @@
 //
 // See ../../../cmd/ld/lib.c:/^pathtoprefix and
 // ../../../cmd/gc/subr.c:/^pathtoprefix.
-func importPathToPrefix(s string) string {
+func goobj_importPathToPrefix(s string) string {
 	// find index of last slash, if any, or else -1.
 	// used for determining whether an index is after the last slash.
 	slash := strings.LastIndex(s, "/")
@@ -284,21 +290,21 @@
 }
 
 // init initializes r to read package p from f.
-func (r *objReader) init(f io.ReadSeeker, p *Package) {
+func (r *goobj_objReader) init(f io.ReadSeeker, p *goobj_Package) {
 	r.f = f
 	r.p = p
 	r.offset, _ = f.Seek(0, 1)
 	r.limit, _ = f.Seek(0, 2)
 	f.Seek(r.offset, 0)
 	r.b = bufio.NewReader(f)
-	r.pkgprefix = importPathToPrefix(p.ImportPath) + "."
+	r.pkgprefix = goobj_importPathToPrefix(p.ImportPath) + "."
 }
 
 // error records that an error occurred.
 // It returns only the first error, so that an error
 // caused by an earlier error does not discard information
 // about the earlier error.
-func (r *objReader) error(err error) error {
+func (r *goobj_objReader) error(err error) error {
 	if r.err == nil {
 		if err == io.EOF {
 			err = io.ErrUnexpectedEOF
@@ -314,7 +320,7 @@
 // A sequence of 0 bytes will eventually terminate any
 // parsing state in the object file. In particular, it ends the
 // reading of a varint.
-func (r *objReader) readByte() byte {
+func (r *goobj_objReader) readByte() byte {
 	if r.err != nil {
 		return 0
 	}
@@ -339,7 +345,7 @@
 // If an error occurs, read returns the error but also
 // records it, so it is safe for callers to ignore the result
 // as long as delaying the report is not a problem.
-func (r *objReader) readFull(b []byte) error {
+func (r *goobj_objReader) readFull(b []byte) error {
 	if r.err != nil {
 		return r.err
 	}
@@ -355,12 +361,12 @@
 }
 
 // readInt reads a zigzag varint from the input file.
-func (r *objReader) readInt() int {
+func (r *goobj_objReader) readInt() int {
 	var u uint64
 
 	for shift := uint(0); ; shift += 7 {
 		if shift >= 64 {
-			r.error(errCorruptObject)
+			r.error(goobj_errCorruptObject)
 			return 0
 		}
 		c := r.readByte()
@@ -372,14 +378,14 @@
 
 	v := int64(u>>1) ^ (int64(u) << 63 >> 63)
 	if int64(int(v)) != v {
-		r.error(errCorruptObject) // TODO
+		r.error(goobj_errCorruptObject) // TODO
 		return 0
 	}
 	return int(v)
 }
 
 // readString reads a length-delimited string from the input file.
-func (r *objReader) readString() string {
+func (r *goobj_objReader) readString() string {
 	n := r.readInt()
 	buf := make([]byte, n)
 	r.readFull(buf)
@@ -387,7 +393,7 @@
 }
 
 // readSymID reads a SymID from the input file.
-func (r *objReader) readSymID() SymID {
+func (r *goobj_objReader) readSymID() goobj_SymID {
 	name, vers := r.readString(), r.readInt()
 
 	// In a symbol name in an object file, "". denotes the
@@ -403,19 +409,19 @@
 		vers = r.p.MaxVersion
 	}
 
-	return SymID{name, vers}
+	return goobj_SymID{name, vers}
 }
 
 // readData reads a data reference from the input file.
-func (r *objReader) readData() Data {
+func (r *goobj_objReader) readData() goobj_Data {
 	n := r.readInt()
-	d := Data{Offset: r.offset, Size: int64(n)}
+	d := goobj_Data{Offset: r.offset, Size: int64(n)}
 	r.skip(int64(n))
 	return d
 }
 
 // skip skips n bytes in the input.
-func (r *objReader) skip(n int64) {
+func (r *goobj_objReader) skip(n int64) {
 	if n < 0 {
 		r.error(fmt.Errorf("debug/goobj: internal error: misuse of skip"))
 	}
@@ -444,14 +450,14 @@
 
 // Parse parses an object file or archive from r,
 // assuming that its import path is pkgpath.
-func Parse(r io.ReadSeeker, pkgpath string) (*Package, error) {
+func goobj_Parse(r io.ReadSeeker, pkgpath string) (*goobj_Package, error) {
 	if pkgpath == "" {
 		pkgpath = `""`
 	}
-	p := new(Package)
+	p := new(goobj_Package)
 	p.ImportPath = pkgpath
 
-	var rd objReader
+	var rd goobj_objReader
 	rd.init(r, p)
 	err := rd.readFull(rd.tmp[:8])
 	if err != nil {
@@ -463,14 +469,14 @@
 
 	switch {
 	default:
-		return nil, errNotObject
+		return nil, goobj_errNotObject
 
-	case bytes.Equal(rd.tmp[:8], archiveHeader):
+	case bytes.Equal(rd.tmp[:8], goobj_archiveHeader):
 		if err := rd.parseArchive(); err != nil {
 			return nil, err
 		}
-	case bytes.Equal(rd.tmp[:8], goobjHeader):
-		if err := rd.parseObject(goobjHeader); err != nil {
+	case bytes.Equal(rd.tmp[:8], goobj_goobjHeader):
+		if err := rd.parseObject(goobj_goobjHeader); err != nil {
 			return nil, err
 		}
 	}
@@ -480,7 +486,7 @@
 
 // trimSpace removes trailing spaces from b and returns the corresponding string.
 // This effectively parses the form used in archive headers.
-func trimSpace(b []byte) string {
+func goobj_trimSpace(b []byte) string {
 	return string(bytes.TrimRight(b, " "))
 }
 
@@ -488,7 +494,7 @@
 // TODO(rsc): Need to skip non-Go object files.
 // TODO(rsc): Maybe record table of contents in r.p so that
 // linker can avoid having code to parse archives too.
-func (r *objReader) parseArchive() error {
+func (r *goobj_objReader) parseArchive() error {
 	for r.offset < r.limit {
 		if err := r.readFull(r.tmp[:60]); err != nil {
 			return err
@@ -512,20 +518,20 @@
 		// The file data that follows is padded to an even number of bytes:
 		// if size is odd, an extra padding byte is inserted betw the next header.
 		if len(data) < 60 {
-			return errTruncatedArchive
+			return goobj_errTruncatedArchive
 		}
-		if !bytes.Equal(data[58:60], archiveMagic) {
-			return errCorruptArchive
+		if !bytes.Equal(data[58:60], goobj_archiveMagic) {
+			return goobj_errCorruptArchive
 		}
-		name := trimSpace(data[0:16])
-		size, err := strconv.ParseInt(trimSpace(data[48:58]), 10, 64)
+		name := goobj_trimSpace(data[0:16])
+		size, err := strconv.ParseInt(goobj_trimSpace(data[48:58]), 10, 64)
 		if err != nil {
-			return errCorruptArchive
+			return goobj_errCorruptArchive
 		}
 		data = data[60:]
 		fsize := size + size&1
 		if fsize < 0 || fsize < size {
-			return errCorruptArchive
+			return goobj_errCorruptArchive
 		}
 		switch name {
 		case "__.SYMDEF", "__.GOSYMDEF", "__.PKGDEF":
@@ -553,7 +559,7 @@
 // and then the part we want to parse begins.
 // The format of that part is defined in a comment at the top
 // of src/liblink/objfile.c.
-func (r *objReader) parseObject(prefix []byte) error {
+func (r *goobj_objReader) parseObject(prefix []byte) error {
 	// TODO(rsc): Maybe use prefix and the initial input to
 	// record the header line from the file, which would
 	// give the architecture and other version information.
@@ -563,7 +569,7 @@
 	for {
 		c1, c2, c3 = c2, c3, r.readByte()
 		if c3 == 0 { // NUL or EOF, either is bad
-			return errCorruptObject
+			return goobj_errCorruptObject
 		}
 		if c1 == '\n' && c2 == '!' && c3 == '\n' {
 			break
@@ -572,12 +578,12 @@
 
 	r.readFull(r.tmp[:8])
 	if !bytes.Equal(r.tmp[:8], []byte("\x00\x00go13ld")) {
-		return r.error(errCorruptObject)
+		return r.error(goobj_errCorruptObject)
 	}
 
 	b := r.readByte()
 	if b != 1 {
-		return r.error(errCorruptObject)
+		return r.error(goobj_errCorruptObject)
 	}
 
 	// Direct package dependencies.
@@ -593,20 +599,20 @@
 	for {
 		if b := r.readByte(); b != 0xfe {
 			if b != 0xff {
-				return r.error(errCorruptObject)
+				return r.error(goobj_errCorruptObject)
 			}
 			break
 		}
 
 		typ := r.readInt()
-		s := &Sym{SymID: r.readSymID()}
+		s := &goobj_Sym{goobj_SymID: r.readSymID()}
 		r.p.Syms = append(r.p.Syms, s)
-		s.Kind = SymKind(typ)
+		s.Kind = goobj_SymKind(typ)
 		s.DupOK = r.readInt() != 0
 		s.Size = r.readInt()
 		s.Type = r.readSymID()
 		s.Data = r.readData()
-		s.Reloc = make([]Reloc, r.readInt())
+		s.Reloc = make([]goobj_Reloc, r.readInt())
 		for i := range s.Reloc {
 			rel := &s.Reloc[i]
 			rel.Offset = r.readInt()
@@ -618,14 +624,14 @@
 			r.readSymID() // Xsym - ignored
 		}
 
-		if s.Kind == STEXT {
-			f := new(Func)
+		if s.Kind == goobj_STEXT {
+			f := new(goobj_Func)
 			s.Func = f
 			f.Args = r.readInt()
 			f.Frame = r.readInt()
 			f.Leaf = r.readInt() != 0
 			f.NoSplit = r.readInt() != 0
-			f.Var = make([]Var, r.readInt())
+			f.Var = make([]goobj_Var, r.readInt())
 			for i := range f.Var {
 				v := &f.Var[i]
 				v.Name = r.readSymID().Name
@@ -637,11 +643,11 @@
 			f.PCSP = r.readData()
 			f.PCFile = r.readData()
 			f.PCLine = r.readData()
-			f.PCData = make([]Data, r.readInt())
+			f.PCData = make([]goobj_Data, r.readInt())
 			for i := range f.PCData {
 				f.PCData[i] = r.readData()
 			}
-			f.FuncData = make([]FuncData, r.readInt())
+			f.FuncData = make([]goobj_FuncData, r.readInt())
 			for i := range f.FuncData {
 				f.FuncData[i].Sym = r.readSymID()
 			}
@@ -657,7 +663,7 @@
 
 	r.readFull(r.tmp[:7])
 	if !bytes.Equal(r.tmp[:7], []byte("\xffgo13ld")) {
-		return r.error(errCorruptObject)
+		return r.error(goobj_errCorruptObject)
 	}
 
 	return nil
diff --git a/src/cmd/nm/goobj.go b/src/cmd/nm/goobj.go
index b0de51d..5e0817d 100644
--- a/src/cmd/nm/goobj.go
+++ b/src/cmd/nm/goobj.go
@@ -7,12 +7,11 @@
 package main
 
 import (
-	"debug/goobj"
 	"fmt"
 	"os"
 )
 
-func goobjName(id goobj.SymID) string {
+func goobjName(id goobj_SymID) string {
 	if id.Version == 0 {
 		return id.Name
 	}
@@ -20,28 +19,28 @@
 }
 
 func goobjSymbols(f *os.File) []Sym {
-	pkg, err := goobj.Parse(f, `""`)
+	pkg, err := goobj_Parse(f, `""`)
 	if err != nil {
 		errorf("parsing %s: %v", f.Name(), err)
 		return nil
 	}
 
-	seen := make(map[goobj.SymID]bool)
+	seen := make(map[goobj_SymID]bool)
 
 	var syms []Sym
 	for _, s := range pkg.Syms {
-		seen[s.SymID] = true
-		sym := Sym{Addr: uint64(s.Data.Offset), Name: goobjName(s.SymID), Size: int64(s.Size), Type: s.Type.Name, Code: '?'}
+		seen[s.goobj_SymID] = true
+		sym := Sym{Addr: uint64(s.Data.Offset), Name: goobjName(s.goobj_SymID), Size: int64(s.Size), Type: s.Type.Name, Code: '?'}
 		switch s.Kind {
-		case goobj.STEXT, goobj.SELFRXSECT:
+		case goobj_STEXT, goobj_SELFRXSECT:
 			sym.Code = 'T'
-		case goobj.STYPE, goobj.SSTRING, goobj.SGOSTRING, goobj.SGOFUNC, goobj.SRODATA, goobj.SFUNCTAB, goobj.STYPELINK, goobj.SSYMTAB, goobj.SPCLNTAB, goobj.SELFROSECT:
+		case goobj_STYPE, goobj_SSTRING, goobj_SGOSTRING, goobj_SGOFUNC, goobj_SRODATA, goobj_SFUNCTAB, goobj_STYPELINK, goobj_SSYMTAB, goobj_SPCLNTAB, goobj_SELFROSECT:
 			sym.Code = 'R'
-		case goobj.SMACHOPLT, goobj.SELFSECT, goobj.SMACHO, goobj.SMACHOGOT, goobj.SNOPTRDATA, goobj.SINITARR, goobj.SDATA, goobj.SWINDOWS:
+		case goobj_SMACHOPLT, goobj_SELFSECT, goobj_SMACHO, goobj_SMACHOGOT, goobj_SNOPTRDATA, goobj_SINITARR, goobj_SDATA, goobj_SWINDOWS:
 			sym.Code = 'D'
-		case goobj.SBSS, goobj.SNOPTRBSS, goobj.STLSBSS:
+		case goobj_SBSS, goobj_SNOPTRBSS, goobj_STLSBSS:
 			sym.Code = 'B'
-		case goobj.SXREF, goobj.SMACHOSYMSTR, goobj.SMACHOSYMTAB, goobj.SMACHOINDIRECTPLT, goobj.SMACHOINDIRECTGOT, goobj.SFILE, goobj.SFILEPATH, goobj.SCONST, goobj.SDYNIMPORT, goobj.SHOSTOBJ:
+		case goobj_SXREF, goobj_SMACHOSYMSTR, goobj_SMACHOSYMTAB, goobj_SMACHOINDIRECTPLT, goobj_SMACHOINDIRECTGOT, goobj_SFILE, goobj_SFILEPATH, goobj_SCONST, goobj_SDYNIMPORT, goobj_SHOSTOBJ:
 			sym.Code = 'X' // should not see
 		}
 		if s.Version != 0 {
diff --git a/src/pkg/debug/goobj/read_test.go b/src/pkg/debug/goobj/read_test.go
deleted file mode 100644
index dee1405..0000000
--- a/src/pkg/debug/goobj/read_test.go
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2013 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 goobj
-
-import "testing"
-
-var importPathToPrefixTests = []struct {
-	in  string
-	out string
-}{
-	{"runtime", "runtime"},
-	{"sync/atomic", "sync/atomic"},
-	{"code.google.com/p/go.tools/godoc", "code.google.com/p/go.tools/godoc"},
-	{"foo.bar/baz.quux", "foo.bar/baz%2equux"},
-	{"", ""},
-	{"%foo%bar", "%25foo%25bar"},
-	{"\x01\x00\x7F☺", "%01%00%7f%e2%98%ba"},
-}
-
-func TestImportPathToPrefix(t *testing.T) {
-	for _, tt := range importPathToPrefixTests {
-		if out := importPathToPrefix(tt.in); out != tt.out {
-			t.Errorf("importPathToPrefix(%q) = %q, want %q", tt.in, out, tt.out)
-		}
-	}
-}