[dev.power64] code review 152570049: all: merge default into dev.power64

src/cmd/objdump/main.go

 // 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
 //
@@ skipping 32 matching lines @@
         "flag"
         "fmt"
         "io"
         "log"
         "os"
         "regexp"
         "sort"
         "strconv"
         "strings"
         "text/tabwriter"
+
+        "cmd/internal/rsc.io/arm/armasm"
+        "cmd/internal/rsc.io/x86/x86asm"
 )
 
 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)
 }
@@ skipping 129 matching lines @@
 
 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)
+        inst, err := x86asm.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)
+                text = x86asm.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)
+        inst, err := armasm.Decode(code, armasm.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})
+                text = armasm.Plan9Syntax(inst, pc, lookup, textReader{code, pc})
         }
         return text, size
 }
 
 var disasms = map[string]disasmFunc{
         "386":   disasm_386,
         "amd64": disasm_amd64,
         "arm":   disasm_arm,
 }
 
@@ skipping 265 matching lines @@
         {[]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 }