src/cmd/objdump/main.go - go - Git at Google

 // Copyright 2012 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.

 // Objdump disassembles executable files.
 //
 // Usage:
 //
 //	go tool objdump [-s symregexp] binary
 //
 // Objdump prints a disassembly of all text symbols (code) in the binary.
 // If the -s option is present, objdump only disassembles
 // symbols with names matching the regular expression.
 //
 // Alternate usage:
 //
 //	go tool objdump binary start end
 //
 // In this mode, objdump disassembles the binary starting at the start address and
 // stopping at the end address. The start and end addresses are program
 // counters written in hexadecimal with optional leading 0x prefix.
 // In this mode, objdump prints a sequence of stanzas of the form:
 //
 //	file:line
 //	 address: assembly
 //	 address: assembly
 //	 ...
 //
 // Each stanza gives the disassembly for a contiguous range of addresses
 // all mapped to the same original source file and line number.
 // This mode is intended for use by pprof.
 //
 // The ARM disassembler is missing (golang.org/issue/7452) but will be added
 // before the Go 1.3 release.
 package main

 import (
 	"bufio"
 	"bytes"
 	"debug/elf"
 	"debug/gosym"
 	"debug/macho"
 	"debug/pe"
 	"debug/plan9obj"
 	"encoding/binary"
 	"flag"
 	"fmt"
 	"io"
 	"log"
 	"os"
 	"regexp"
 	"sort"
 	"strconv"
 	"strings"
 	"text/tabwriter"
 )

 var symregexp = flag.String("s", "", "only dump symbols matching this regexp")
 var symRE *regexp.Regexp

 func usage() {
 	fmt.Fprintf(os.Stderr, "usage: go tool objdump [-s symregexp] binary [start end]\n\n")
 	flag.PrintDefaults()
 	os.Exit(2)
 }

 type lookupFunc func(addr uint64) (sym string, base uint64)
 type disasmFunc func(code []byte, pc uint64, lookup lookupFunc) (text string, size int)

 func main() {
 	log.SetFlags(0)
 	log.SetPrefix("objdump: ")

 	flag.Usage = usage
 	flag.Parse()
 	if flag.NArg() != 1 && flag.NArg() != 3 {
 		usage()
 	}

 	if *symregexp != "" {
 		re, err := regexp.Compile(*symregexp)
 		if err != nil {
 			log.Fatalf("invalid -s regexp: %v", err)
 		}
 		symRE = re
 	}

 	f, err := os.Open(flag.Arg(0))
 	if err != nil {
 		log.Fatal(err)
 	}

 	textStart, textData, symtab, pclntab, err := loadTables(f)
 	if err != nil {
 		log.Fatalf("reading %s: %v", flag.Arg(0), err)
 	}

 	syms, goarch, err := loadSymbols(f)
 	if err != nil {
 		log.Fatalf("reading %s: %v", flag.Arg(0), err)
 	}

 	// Filter out section symbols, overwriting syms in place.
 	keep := syms[:0]
 	for _, sym := range syms {
 		switch sym.Name {
 		case "text", "_text", "etext", "_etext":
 			// drop
 		default:
 			keep = append(keep, sym)
 		}
 	}
 	syms = keep

 	disasm := disasms[goarch]
 	if disasm == nil {
 		log.Fatalf("reading %s: unknown architecture", flag.Arg(0))
 	}

 	lookup := func(addr uint64) (string, uint64) {
 		i := sort.Search(len(syms), func(i int) bool { return syms[i].Addr > addr })
 		if i > 0 {
 			s := syms[i-1]
 			if s.Addr <= addr && addr < s.Addr+uint64(s.Size) && s.Name != "etext" && s.Name != "_etext" {
 				return s.Name, s.Addr
 			}
 		}
 		return "", 0
 	}

 	pcln := gosym.NewLineTable(pclntab, textStart)
 	tab, err := gosym.NewTable(symtab, pcln)
 	if err != nil {
 		log.Fatalf("reading %s: %v", flag.Arg(0), err)
 	}

 	if flag.NArg() == 1 {
 		// disassembly of entire object - our format
 		dump(tab, lookup, disasm, goarch, syms, textData, textStart)
 		os.Exit(exitCode)
 	}

 	// disassembly of specific piece of object - gnu objdump format for pprof
 	gnuDump(tab, lookup, disasm, textData, textStart)
 	os.Exit(exitCode)
 }

 // base returns the final element in the path.
 // It works on both Windows and Unix paths.
 func base(path string) string {
 	path = path[strings.LastIndex(path, "/")+1:]
 	path = path[strings.LastIndex(path, `\`)+1:]
 	return path
 }

 func dump(tab *gosym.Table, lookup lookupFunc, disasm disasmFunc, goarch string, syms []Sym, textData []byte, textStart uint64) {
 	stdout := bufio.NewWriter(os.Stdout)
 	defer stdout.Flush()

 	printed := false
 	for _, sym := range syms {
 		if sym.Code != 'T' || sym.Size == 0 || sym.Name == "_text" || sym.Name == "text" || sym.Addr < textStart || symRE != nil && !symRE.MatchString(sym.Name) {
 			continue
 		}
 		if sym.Addr >= textStart+uint64(len(textData)) || sym.Addr+uint64(sym.Size) > textStart+uint64(len(textData)) {
 			break
 		}
 		if printed {
 			fmt.Fprintf(stdout, "\n")
 		} else {
 			printed = true
 		}
 		file, _, _ := tab.PCToLine(sym.Addr)
 		fmt.Fprintf(stdout, "TEXT %s(SB) %s\n", sym.Name, file)
 		tw := tabwriter.NewWriter(stdout, 1, 8, 1, '\t', 0)
 		start := sym.Addr
 		end := sym.Addr + uint64(sym.Size)
 		for pc := start; pc < end; {
 			i := pc - textStart
 			text, size := disasm(textData[i:end-textStart], pc, lookup)
 			file, line, _ := tab.PCToLine(pc)

 			// ARM is word-based, so show actual word hex, not byte hex.
 			// Since ARM is little endian, they're different.
 			if goarch == "arm" && size == 4 {
 				fmt.Fprintf(tw, "\t%s:%d\t%#x\t%08x\t%s\n", base(file), line, pc, binary.LittleEndian.Uint32(textData[i:i+uint64(size)]), text)
 			} else {
 				fmt.Fprintf(tw, "\t%s:%d\t%#x\t%x\t%s\n", base(file), line, pc, textData[i:i+uint64(size)], text)
 			}
 			pc += uint64(size)
 		}
 		tw.Flush()
 	}
 }

 func disasm_386(code []byte, pc uint64, lookup lookupFunc) (string, int) {
 	return disasm_x86(code, pc, lookup, 32)
 }

 func disasm_amd64(code []byte, pc uint64, lookup lookupFunc) (string, int) {
 	return disasm_x86(code, pc, lookup, 64)
 }

 func disasm_x86(code []byte, pc uint64, lookup lookupFunc, arch int) (string, int) {
 	inst, err := x86_Decode(code, 64)
 	var text string
 	size := inst.Len
 	if err != nil || size == 0 || inst.Op == 0 {
 		size = 1
 		text = "?"
 	} else {
 		text = x86_plan9Syntax(inst, pc, lookup)
 	}
 	return text, size
 }

 type textReader struct {
 	code []byte
 	pc   uint64
 }

 func (r textReader) ReadAt(data []byte, off int64) (n int, err error) {
 	if off < 0 || uint64(off) < r.pc {
 		return 0, io.EOF
 	}
 	d := uint64(off) - r.pc
 	if d >= uint64(len(r.code)) {
 		return 0, io.EOF
 	}
 	n = copy(data, r.code[d:])
 	if n < len(data) {
 		err = io.ErrUnexpectedEOF
 	}
 	return
 }

 func disasm_arm(code []byte, pc uint64, lookup lookupFunc) (string, int) {
 	inst, err := arm_Decode(code, arm_ModeARM)
 	var text string
 	size := inst.Len
 	if err != nil || size == 0 || inst.Op == 0 {
 		size = 4
 		text = "?"
 	} else {
 		text = arm_plan9Syntax(inst, pc, lookup, textReader{code, pc})
 	}
 	return text, size
 }

 var disasms = map[string]disasmFunc{
 	"386":   disasm_386,
 	"amd64": disasm_amd64,
 	"arm":   disasm_arm,
 }

 func gnuDump(tab *gosym.Table, lookup lookupFunc, disasm disasmFunc, textData []byte, textStart uint64) {
 	start, err := strconv.ParseUint(strings.TrimPrefix(flag.Arg(1), "0x"), 16, 64)
 	if err != nil {
 		log.Fatalf("invalid start PC: %v", err)
 	}
 	end, err := strconv.ParseUint(strings.TrimPrefix(flag.Arg(2), "0x"), 16, 64)
 	if err != nil {
 		log.Fatalf("invalid end PC: %v", err)
 	}
 	if start < textStart {
 		start = textStart
 	}
 	if end < start {
 		end = start
 	}
 	if end > textStart+uint64(len(textData)) {
 		end = textStart + uint64(len(textData))
 	}

 	stdout := bufio.NewWriter(os.Stdout)
 	defer stdout.Flush()

 	// For now, find spans of same PC/line/fn and
 	// emit them as having dummy instructions.
 	var (
 		spanPC   uint64
 		spanFile string
 		spanLine int
 		spanFn   *gosym.Func
 	)

 	flush := func(endPC uint64) {
 		if spanPC == 0 {
 			return
 		}
 		fmt.Fprintf(stdout, "%s:%d\n", spanFile, spanLine)
 		for pc := spanPC; pc < endPC; {
 			text, size := disasm(textData[pc-textStart:], pc, lookup)
 			fmt.Fprintf(stdout, " %x: %s\n", pc, text)
 			pc += uint64(size)
 		}
 		spanPC = 0
 	}

 	for pc := start; pc < end; pc++ {
 		file, line, fn := tab.PCToLine(pc)
 		if file != spanFile || line != spanLine || fn != spanFn {
 			flush(pc)
 			spanPC, spanFile, spanLine, spanFn = pc, file, line, fn
 		}
 	}
 	flush(end)
 }

 func loadTables(f *os.File) (textStart uint64, textData, symtab, pclntab []byte, err error) {
 	if obj, err := elf.NewFile(f); err == nil {
 		if sect := obj.Section(".text"); sect != nil {
 			textStart = sect.Addr
 			textData, _ = sect.Data()
 		}
 		if sect := obj.Section(".gosymtab"); sect != nil {
 			if symtab, err = sect.Data(); err != nil {
 				return 0, nil, nil, nil, err
 			}
 		}
 		if sect := obj.Section(".gopclntab"); sect != nil {
 			if pclntab, err = sect.Data(); err != nil {
 				return 0, nil, nil, nil, err
 			}
 		}
 		return textStart, textData, symtab, pclntab, nil
 	}

 	if obj, err := macho.NewFile(f); err == nil {
 		if sect := obj.Section("__text"); sect != nil {
 			textStart = sect.Addr
 			textData, _ = sect.Data()
 		}
 		if sect := obj.Section("__gosymtab"); sect != nil {
 			if symtab, err = sect.Data(); err != nil {
 				return 0, nil, nil, nil, err
 			}
 		}
 		if sect := obj.Section("__gopclntab"); sect != nil {
 			if pclntab, err = sect.Data(); err != nil {
 				return 0, nil, nil, nil, err
 			}
 		}
 		return textStart, textData, symtab, pclntab, nil
 	}

 	if obj, err := pe.NewFile(f); err == nil {
 		var imageBase uint64
 		switch oh := obj.OptionalHeader.(type) {
 		case *pe.OptionalHeader32:
 			imageBase = uint64(oh.ImageBase)
 		case *pe.OptionalHeader64:
 			imageBase = oh.ImageBase
 		default:
 			return 0, nil, nil, nil, fmt.Errorf("pe file format not recognized")
 		}
 		if sect := obj.Section(".text"); sect != nil {
 			textStart = imageBase + uint64(sect.VirtualAddress)
 			textData, _ = sect.Data()
 		}
 		if pclntab, err = loadPETable(obj, "pclntab", "epclntab"); err != nil {
 			return 0, nil, nil, nil, err
 		}
 		if symtab, err = loadPETable(obj, "symtab", "esymtab"); err != nil {
 			return 0, nil, nil, nil, err
 		}
 		return textStart, textData, symtab, pclntab, nil
 	}

 	if obj, err := plan9obj.NewFile(f); err == nil {
 		sym, err := findPlan9Symbol(obj, "text")
 		if err != nil {
 			return 0, nil, nil, nil, err
 		}
 		textStart = sym.Value
 		if sect := obj.Section("text"); sect != nil {
 			textData, _ = sect.Data()
 		}
 		if pclntab, err = loadPlan9Table(obj, "pclntab", "epclntab"); err != nil {
 			return 0, nil, nil, nil, err
 		}
 		if symtab, err = loadPlan9Table(obj, "symtab", "esymtab"); err != nil {
 			return 0, nil, nil, nil, err
 		}
 		return textStart, textData, symtab, pclntab, nil
 	}

 	return 0, nil, nil, nil, fmt.Errorf("unrecognized binary format")
 }

 func findPESymbol(f *pe.File, name string) (*pe.Symbol, error) {
 	for _, s := range f.Symbols {
 		if s.Name != name {
 			continue
 		}
 		if s.SectionNumber <= 0 {
 			return nil, fmt.Errorf("symbol %s: invalid section number %d", name, s.SectionNumber)
 		}
 		if len(f.Sections) < int(s.SectionNumber) {
 			return nil, fmt.Errorf("symbol %s: section number %d is larger than max %d", name, s.SectionNumber, len(f.Sections))
 		}
 		return s, nil
 	}
 	return nil, fmt.Errorf("no %s symbol found", name)
 }

 func loadPETable(f *pe.File, sname, ename string) ([]byte, error) {
 	ssym, err := findPESymbol(f, sname)
 	if err != nil {
 		return nil, err
 	}
 	esym, err := findPESymbol(f, ename)
 	if err != nil {
 		return nil, err
 	}
 	if ssym.SectionNumber != esym.SectionNumber {
 		return nil, fmt.Errorf("%s and %s symbols must be in the same section", sname, ename)
 	}
 	sect := f.Sections[ssym.SectionNumber-1]
 	data, err := sect.Data()
 	if err != nil {
 		return nil, err
 	}
 	return data[ssym.Value:esym.Value], nil
 }

 func findPlan9Symbol(f *plan9obj.File, name string) (*plan9obj.Sym, error) {
 	syms, err := f.Symbols()
 	if err != nil {
 		return nil, err
 	}
 	for _, s := range syms {
 		if s.Name != name {
 			continue
 		}
 		return &s, nil
 	}
 	return nil, fmt.Errorf("no %s symbol found", name)
 }

 func loadPlan9Table(f *plan9obj.File, sname, ename string) ([]byte, error) {
 	ssym, err := findPlan9Symbol(f, sname)
 	if err != nil {
 		return nil, err
 	}
 	esym, err := findPlan9Symbol(f, ename)
 	if err != nil {
 		return nil, err
 	}
 	text, err := findPlan9Symbol(f, "text")
 	if err != nil {
 		return nil, err
 	}
 	sect := f.Section("text")
 	if sect == nil {
 		return nil, err
 	}
 	data, err := sect.Data()
 	if err != nil {
 		return nil, err
 	}
 	return data[ssym.Value-text.Value : esym.Value-text.Value], nil
 }

 // TODO(rsc): This code is taken from cmd/nm. Arrange some way to share the code.

 var exitCode = 0

 func errorf(format string, args ...interface{}) {
 	log.Printf(format, args...)
 	exitCode = 1
 }

 func loadSymbols(f *os.File) (syms []Sym, goarch string, err error) {
 	f.Seek(0, 0)
 	buf := make([]byte, 16)
 	io.ReadFull(f, buf)
 	f.Seek(0, 0)

 	for _, p := range parsers {
 		if bytes.HasPrefix(buf, p.prefix) {
 			syms, goarch = p.parse(f)
 			sort.Sort(byAddr(syms))
 			return
 		}
 	}
 	err = fmt.Errorf("unknown file format")
 	return
 }

 type Sym struct {
 	Addr uint64
 	Size int64
 	Code rune
 	Name string
 	Type string
 }

 var parsers = []struct {
 	prefix []byte
 	parse  func(*os.File) ([]Sym, string)
 }{
 	{[]byte("\x7FELF"), elfSymbols},
 	{[]byte("\xFE\xED\xFA\xCE"), machoSymbols},
 	{[]byte("\xFE\xED\xFA\xCF"), machoSymbols},
 	{[]byte("\xCE\xFA\xED\xFE"), machoSymbols},
 	{[]byte("\xCF\xFA\xED\xFE"), machoSymbols},
 	{[]byte("MZ"), peSymbols},
 	{[]byte("\x00\x00\x01\xEB"), plan9Symbols}, // 386
 	{[]byte("\x00\x00\x04\x07"), plan9Symbols}, // mips
 	{[]byte("\x00\x00\x06\x47"), plan9Symbols}, // arm
 	{[]byte("\x00\x00\x8A\x97"), plan9Symbols}, // amd64
 }

 type byAddr []Sym

 func (x byAddr) Len() int           { return len(x) }
 func (x byAddr) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
 func (x byAddr) Less(i, j int) bool { return x[i].Addr < x[j].Addr }
	// Copyright 2012 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.

	// Objdump disassembles executable files.
	//
	// Usage:
	//
	// go tool objdump [-s symregexp] binary
	//
	// Objdump prints a disassembly of all text symbols (code) in the binary.
	// If the -s option is present, objdump only disassembles
	// symbols with names matching the regular expression.
	//
	// Alternate usage:
	//
	// go tool objdump binary start end
	//
	// In this mode, objdump disassembles the binary starting at the start address and
	// stopping at the end address. The start and end addresses are program
	// counters written in hexadecimal with optional leading 0x prefix.
	// In this mode, objdump prints a sequence of stanzas of the form:
	//
	// file:line
	// address: assembly
	// address: assembly
	// ...
	//
	// Each stanza gives the disassembly for a contiguous range of addresses
	// all mapped to the same original source file and line number.
	// This mode is intended for use by pprof.
	//
	// The ARM disassembler is missing (golang.org/issue/7452) but will be added
	// before the Go 1.3 release.
	package main

	import (
	"bufio"
	"bytes"
	"debug/elf"
	"debug/gosym"
	"debug/macho"
	"debug/pe"
	"debug/plan9obj"
	"encoding/binary"
	"flag"
	"fmt"
	"io"
	"log"
	"os"
	"regexp"
	"sort"
	"strconv"
	"strings"
	"text/tabwriter"
	)

	var symregexp = flag.String("s", "", "only dump symbols matching this regexp")
	var symRE *regexp.Regexp

	func usage() {
	fmt.Fprintf(os.Stderr, "usage: go tool objdump [-s symregexp] binary [start end]\n\n")
	flag.PrintDefaults()
	os.Exit(2)
	}

	type lookupFunc func(addr uint64) (sym string, base uint64)
	type disasmFunc func(code []byte, pc uint64, lookup lookupFunc) (text string, size int)

	func main() {
	log.SetFlags(0)
	log.SetPrefix("objdump: ")

	flag.Usage = usage
	flag.Parse()
	if flag.NArg() != 1 && flag.NArg() != 3 {
	usage()
	}

	if *symregexp != "" {
	re, err := regexp.Compile(*symregexp)
	if err != nil {
	log.Fatalf("invalid -s regexp: %v", err)
	}
	symRE = re
	}

	f, err := os.Open(flag.Arg(0))
	if err != nil {
	log.Fatal(err)
	}

	textStart, textData, symtab, pclntab, err := loadTables(f)
	if err != nil {
	log.Fatalf("reading %s: %v", flag.Arg(0), err)
	}

	syms, goarch, err := loadSymbols(f)
	if err != nil {
	log.Fatalf("reading %s: %v", flag.Arg(0), err)
	}

	// Filter out section symbols, overwriting syms in place.
	keep := syms[:0]
	for _, sym := range syms {
	switch sym.Name {
	case "text", "_text", "etext", "_etext":
	// drop
	default:
	keep = append(keep, sym)
	}
	}
	syms = keep

	disasm := disasms[goarch]
	if disasm == nil {
	log.Fatalf("reading %s: unknown architecture", flag.Arg(0))
	}

	lookup := func(addr uint64) (string, uint64) {
	i := sort.Search(len(syms), func(i int) bool { return syms[i].Addr > addr })
	if i > 0 {
	s := syms[i-1]
	if s.Addr <= addr && addr < s.Addr+uint64(s.Size) && s.Name != "etext" && s.Name != "_etext" {
	return s.Name, s.Addr
	}
	}
	return "", 0
	}

	pcln := gosym.NewLineTable(pclntab, textStart)
	tab, err := gosym.NewTable(symtab, pcln)
	if err != nil {
	log.Fatalf("reading %s: %v", flag.Arg(0), err)
	}

	if flag.NArg() == 1 {
	// disassembly of entire object - our format
	dump(tab, lookup, disasm, goarch, syms, textData, textStart)
	os.Exit(exitCode)
	}

	// disassembly of specific piece of object - gnu objdump format for pprof
	gnuDump(tab, lookup, disasm, textData, textStart)
	os.Exit(exitCode)
	}

	// base returns the final element in the path.
	// It works on both Windows and Unix paths.
	func base(path string) string {
	path = path[strings.LastIndex(path, "/")+1:]
	path = path[strings.LastIndex(path, `\`)+1:]
	return path
	}

	func dump(tab *gosym.Table, lookup lookupFunc, disasm disasmFunc, goarch string, syms []Sym, textData []byte, textStart uint64) {
	stdout := bufio.NewWriter(os.Stdout)
	defer stdout.Flush()

	printed := false
	for _, sym := range syms {
	if sym.Code != 'T' \|\| sym.Size == 0 \|\| sym.Name == "_text" \|\| sym.Name == "text" \|\| sym.Addr < textStart \|\| symRE != nil && !symRE.MatchString(sym.Name) {
	continue
	}
	if sym.Addr >= textStart+uint64(len(textData)) \|\| sym.Addr+uint64(sym.Size) > textStart+uint64(len(textData)) {
	break
	}
	if printed {
	fmt.Fprintf(stdout, "\n")
	} else {
	printed = true
	}
	file, _, _ := tab.PCToLine(sym.Addr)
	fmt.Fprintf(stdout, "TEXT %s(SB) %s\n", sym.Name, file)
	tw := tabwriter.NewWriter(stdout, 1, 8, 1, '\t', 0)
	start := sym.Addr
	end := sym.Addr + uint64(sym.Size)
	for pc := start; pc < end; {
	i := pc - textStart
	text, size := disasm(textData[i:end-textStart], pc, lookup)
	file, line, _ := tab.PCToLine(pc)

	// ARM is word-based, so show actual word hex, not byte hex.
	// Since ARM is little endian, they're different.
	if goarch == "arm" && size == 4 {
	fmt.Fprintf(tw, "\t%s:%d\t%#x\t%08x\t%s\n", base(file), line, pc, binary.LittleEndian.Uint32(textData[i:i+uint64(size)]), text)
	} else {
	fmt.Fprintf(tw, "\t%s:%d\t%#x\t%x\t%s\n", base(file), line, pc, textData[i:i+uint64(size)], text)
	}
	pc += uint64(size)
	}
	tw.Flush()
	}
	}

	func disasm_386(code []byte, pc uint64, lookup lookupFunc) (string, int) {
	return disasm_x86(code, pc, lookup, 32)
	}

	func disasm_amd64(code []byte, pc uint64, lookup lookupFunc) (string, int) {
	return disasm_x86(code, pc, lookup, 64)
	}

	func disasm_x86(code []byte, pc uint64, lookup lookupFunc, arch int) (string, int) {
	inst, err := x86_Decode(code, 64)
	var text string
	size := inst.Len
	if err != nil \|\| size == 0 \|\| inst.Op == 0 {
	size = 1
	text = "?"
	} else {
	text = x86_plan9Syntax(inst, pc, lookup)
	}
	return text, size
	}

	type textReader struct {
	code []byte
	pc uint64
	}

	func (r textReader) ReadAt(data []byte, off int64) (n int, err error) {
	if off < 0 \|\| uint64(off) < r.pc {
	return 0, io.EOF
	}
	d := uint64(off) - r.pc
	if d >= uint64(len(r.code)) {
	return 0, io.EOF
	}
	n = copy(data, r.code[d:])
	if n < len(data) {
	err = io.ErrUnexpectedEOF
	}
	return
	}

	func disasm_arm(code []byte, pc uint64, lookup lookupFunc) (string, int) {
	inst, err := arm_Decode(code, arm_ModeARM)
	var text string
	size := inst.Len
	if err != nil \|\| size == 0 \|\| inst.Op == 0 {
	size = 4
	text = "?"
	} else {
	text = arm_plan9Syntax(inst, pc, lookup, textReader{code, pc})
	}
	return text, size
	}

	var disasms = map[string]disasmFunc{
	"386": disasm_386,
	"amd64": disasm_amd64,
	"arm": disasm_arm,
	}

	func gnuDump(tab *gosym.Table, lookup lookupFunc, disasm disasmFunc, textData []byte, textStart uint64) {
	start, err := strconv.ParseUint(strings.TrimPrefix(flag.Arg(1), "0x"), 16, 64)
	if err != nil {
	log.Fatalf("invalid start PC: %v", err)
	}
	end, err := strconv.ParseUint(strings.TrimPrefix(flag.Arg(2), "0x"), 16, 64)
	if err != nil {
	log.Fatalf("invalid end PC: %v", err)
	}
	if start < textStart {
	start = textStart
	}
	if end < start {
	end = start
	}
	if end > textStart+uint64(len(textData)) {
	end = textStart + uint64(len(textData))
	}

	stdout := bufio.NewWriter(os.Stdout)
	defer stdout.Flush()

	// For now, find spans of same PC/line/fn and
	// emit them as having dummy instructions.
	var (
	spanPC uint64
	spanFile string
	spanLine int
	spanFn *gosym.Func
	)

	flush := func(endPC uint64) {
	if spanPC == 0 {
	return
	}
	fmt.Fprintf(stdout, "%s:%d\n", spanFile, spanLine)
	for pc := spanPC; pc < endPC; {
	text, size := disasm(textData[pc-textStart:], pc, lookup)
	fmt.Fprintf(stdout, " %x: %s\n", pc, text)
	pc += uint64(size)
	}
	spanPC = 0
	}

	for pc := start; pc < end; pc++ {
	file, line, fn := tab.PCToLine(pc)
	if file != spanFile \|\| line != spanLine \|\| fn != spanFn {
	flush(pc)
	spanPC, spanFile, spanLine, spanFn = pc, file, line, fn
	}
	}
	flush(end)
	}

	func loadTables(f *os.File) (textStart uint64, textData, symtab, pclntab []byte, err error) {
	if obj, err := elf.NewFile(f); err == nil {
	if sect := obj.Section(".text"); sect != nil {
	textStart = sect.Addr
	textData, _ = sect.Data()
	}
	if sect := obj.Section(".gosymtab"); sect != nil {
	if symtab, err = sect.Data(); err != nil {
	return 0, nil, nil, nil, err
	}
	}
	if sect := obj.Section(".gopclntab"); sect != nil {
	if pclntab, err = sect.Data(); err != nil {
	return 0, nil, nil, nil, err
	}
	}
	return textStart, textData, symtab, pclntab, nil
	}

	if obj, err := macho.NewFile(f); err == nil {
	if sect := obj.Section("__text"); sect != nil {
	textStart = sect.Addr
	textData, _ = sect.Data()
	}
	if sect := obj.Section("__gosymtab"); sect != nil {
	if symtab, err = sect.Data(); err != nil {
	return 0, nil, nil, nil, err
	}
	}
	if sect := obj.Section("__gopclntab"); sect != nil {
	if pclntab, err = sect.Data(); err != nil {
	return 0, nil, nil, nil, err
	}
	}
	return textStart, textData, symtab, pclntab, nil
	}

	if obj, err := pe.NewFile(f); err == nil {
	var imageBase uint64
	switch oh := obj.OptionalHeader.(type) {
	case *pe.OptionalHeader32:
	imageBase = uint64(oh.ImageBase)
	case *pe.OptionalHeader64:
	imageBase = oh.ImageBase
	default:
	return 0, nil, nil, nil, fmt.Errorf("pe file format not recognized")
	}
	if sect := obj.Section(".text"); sect != nil {
	textStart = imageBase + uint64(sect.VirtualAddress)
	textData, _ = sect.Data()
	}
	if pclntab, err = loadPETable(obj, "pclntab", "epclntab"); err != nil {
	return 0, nil, nil, nil, err
	}
	if symtab, err = loadPETable(obj, "symtab", "esymtab"); err != nil {
	return 0, nil, nil, nil, err
	}
	return textStart, textData, symtab, pclntab, nil
	}

	if obj, err := plan9obj.NewFile(f); err == nil {
	sym, err := findPlan9Symbol(obj, "text")
	if err != nil {
	return 0, nil, nil, nil, err
	}
	textStart = sym.Value
	if sect := obj.Section("text"); sect != nil {
	textData, _ = sect.Data()
	}
	if pclntab, err = loadPlan9Table(obj, "pclntab", "epclntab"); err != nil {
	return 0, nil, nil, nil, err
	}
	if symtab, err = loadPlan9Table(obj, "symtab", "esymtab"); err != nil {
	return 0, nil, nil, nil, err
	}
	return textStart, textData, symtab, pclntab, nil
	}

	return 0, nil, nil, nil, fmt.Errorf("unrecognized binary format")
	}

	func findPESymbol(f pe.File, name string) (pe.Symbol, error) {
	for _, s := range f.Symbols {
	if s.Name != name {
	continue
	}
	if s.SectionNumber <= 0 {
	return nil, fmt.Errorf("symbol %s: invalid section number %d", name, s.SectionNumber)
	}
	if len(f.Sections) < int(s.SectionNumber) {
	return nil, fmt.Errorf("symbol %s: section number %d is larger than max %d", name, s.SectionNumber, len(f.Sections))
	}
	return s, nil
	}
	return nil, fmt.Errorf("no %s symbol found", name)
	}

	func loadPETable(f *pe.File, sname, ename string) ([]byte, error) {
	ssym, err := findPESymbol(f, sname)
	if err != nil {
	return nil, err
	}
	esym, err := findPESymbol(f, ename)
	if err != nil {
	return nil, err
	}
	if ssym.SectionNumber != esym.SectionNumber {
	return nil, fmt.Errorf("%s and %s symbols must be in the same section", sname, ename)
	}
	sect := f.Sections[ssym.SectionNumber-1]
	data, err := sect.Data()
	if err != nil {
	return nil, err
	}
	return data[ssym.Value:esym.Value], nil
	}

	func findPlan9Symbol(f plan9obj.File, name string) (plan9obj.Sym, error) {
	syms, err := f.Symbols()
	if err != nil {
	return nil, err
	}
	for _, s := range syms {
	if s.Name != name {
	continue
	}
	return &s, nil
	}
	return nil, fmt.Errorf("no %s symbol found", name)
	}

	func loadPlan9Table(f *plan9obj.File, sname, ename string) ([]byte, error) {
	ssym, err := findPlan9Symbol(f, sname)
	if err != nil {
	return nil, err
	}
	esym, err := findPlan9Symbol(f, ename)
	if err != nil {
	return nil, err
	}
	text, err := findPlan9Symbol(f, "text")
	if err != nil {
	return nil, err
	}
	sect := f.Section("text")
	if sect == nil {
	return nil, err
	}
	data, err := sect.Data()
	if err != nil {
	return nil, err
	}
	return data[ssym.Value-text.Value : esym.Value-text.Value], nil
	}

	// TODO(rsc): This code is taken from cmd/nm. Arrange some way to share the code.

	var exitCode = 0

	func errorf(format string, args ...interface{}) {
	log.Printf(format, args...)
	exitCode = 1
	}

	func loadSymbols(f *os.File) (syms []Sym, goarch string, err error) {
	f.Seek(0, 0)
	buf := make([]byte, 16)
	io.ReadFull(f, buf)
	f.Seek(0, 0)

	for _, p := range parsers {
	if bytes.HasPrefix(buf, p.prefix) {
	syms, goarch = p.parse(f)
	sort.Sort(byAddr(syms))
	return
	}
	}
	err = fmt.Errorf("unknown file format")
	return
	}

	type Sym struct {
	Addr uint64
	Size int64
	Code rune
	Name string
	Type string
	}

	var parsers = []struct {
	prefix []byte
	parse func(*os.File) ([]Sym, string)
	}{
	{[]byte("\x7FELF"), elfSymbols},
	{[]byte("\xFE\xED\xFA\xCE"), machoSymbols},
	{[]byte("\xFE\xED\xFA\xCF"), machoSymbols},
	{[]byte("\xCE\xFA\xED\xFE"), machoSymbols},
	{[]byte("\xCF\xFA\xED\xFE"), machoSymbols},
	{[]byte("MZ"), peSymbols},
	{[]byte("\x00\x00\x01\xEB"), plan9Symbols}, // 386
	{[]byte("\x00\x00\x04\x07"), plan9Symbols}, // mips
	{[]byte("\x00\x00\x06\x47"), plan9Symbols}, // arm
	{[]byte("\x00\x00\x8A\x97"), plan9Symbols}, // amd64
	}

	type byAddr []Sym

	func (x byAddr) Len() int { return len(x) }
	func (x byAddr) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
	func (x byAddr) Less(i, j int) bool { return x[i].Addr < x[j].Addr }