Source file src/cmd/objdump/main.go

     1	// Copyright 2012 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	// Objdump disassembles executable files.
     6	//
     7	// Usage:
     8	//
     9	//	go tool objdump [-s symregexp] binary
    10	//
    11	// Objdump prints a disassembly of all text symbols (code) in the binary.
    12	// If the -s option is present, objdump only disassembles
    13	// symbols with names matching the regular expression.
    14	//
    15	// Alternate usage:
    16	//
    17	//	go tool objdump binary start end
    18	//
    19	// In this mode, objdump disassembles the binary starting at the start address and
    20	// stopping at the end address. The start and end addresses are program
    21	// counters written in hexadecimal with optional leading 0x prefix.
    22	// In this mode, objdump prints a sequence of stanzas of the form:
    23	//
    24	//	file:line
    25	//	 address: assembly
    26	//	 address: assembly
    27	//	 ...
    28	//
    29	// Each stanza gives the disassembly for a contiguous range of addresses
    30	// all mapped to the same original source file and line number.
    31	// This mode is intended for use by pprof.
    32	package main
    33	
    34	import (
    35		"flag"
    36		"fmt"
    37		"log"
    38		"os"
    39		"regexp"
    40		"strconv"
    41		"strings"
    42	
    43		"cmd/internal/objfile"
    44	)
    45	
    46	var printCode = flag.Bool("S", false, "print go code alongside assembly")
    47	var symregexp = flag.String("s", "", "only dump symbols matching this regexp")
    48	var symRE *regexp.Regexp
    49	
    50	func usage() {
    51		fmt.Fprintf(os.Stderr, "usage: go tool objdump [-S] [-s symregexp] binary [start end]\n\n")
    52		flag.PrintDefaults()
    53		os.Exit(2)
    54	}
    55	
    56	func main() {
    57		log.SetFlags(0)
    58		log.SetPrefix("objdump: ")
    59	
    60		flag.Usage = usage
    61		flag.Parse()
    62		if flag.NArg() != 1 && flag.NArg() != 3 {
    63			usage()
    64		}
    65	
    66		if *symregexp != "" {
    67			re, err := regexp.Compile(*symregexp)
    68			if err != nil {
    69				log.Fatalf("invalid -s regexp: %v", err)
    70			}
    71			symRE = re
    72		}
    73	
    74		f, err := objfile.Open(flag.Arg(0))
    75		if err != nil {
    76			log.Fatal(err)
    77		}
    78		defer f.Close()
    79	
    80		dis, err := f.Disasm()
    81		if err != nil {
    82			log.Fatalf("disassemble %s: %v", flag.Arg(0), err)
    83		}
    84	
    85		switch flag.NArg() {
    86		default:
    87			usage()
    88		case 1:
    89			// disassembly of entire object
    90			dis.Print(os.Stdout, symRE, 0, ^uint64(0), *printCode)
    91	
    92		case 3:
    93			// disassembly of PC range
    94			start, err := strconv.ParseUint(strings.TrimPrefix(flag.Arg(1), "0x"), 16, 64)
    95			if err != nil {
    96				log.Fatalf("invalid start PC: %v", err)
    97			}
    98			end, err := strconv.ParseUint(strings.TrimPrefix(flag.Arg(2), "0x"), 16, 64)
    99			if err != nil {
   100				log.Fatalf("invalid end PC: %v", err)
   101			}
   102			dis.Print(os.Stdout, symRE, start, end, *printCode)
   103		}
   104	}
   105	

View as plain text