Support Intel syntax in the assembly reports (#520)

Add support for output assembly in Intel Syntax.

driver/driver.go

 
 	// Disasm disassembles the named object file, starting at
 	// the start address and stopping at (before) the end address.
-	Disasm(file string, start, end uint64) ([]Inst, error)
+	Disasm(file string, start, end uint64, intelSyntax bool) ([]Inst, error)
 }
 
 // An Inst is a single instruction in an assembly listing.
 	return pluginSyms, nil
 }
 
-func (o *internalObjTool) Disasm(file string, start, end uint64) ([]plugin.Inst, error) {
-	insts, err := o.ObjTool.Disasm(file, start, end)
+func (o *internalObjTool) Disasm(file string, start, end uint64, intelSyntax bool) ([]plugin.Inst, error) {
+	insts, err := o.ObjTool.Disasm(file, start, end, intelSyntax)
 	if err != nil {
 		return nil, err
 	}

internal/binutils/binutils.go

 
 // Disasm returns the assembly instructions for the specified address range
 // of a binary.
-func (bu *Binutils) Disasm(file string, start, end uint64) ([]plugin.Inst, error) {
+func (bu *Binutils) Disasm(file string, start, end uint64, intelSyntax bool) ([]plugin.Inst, error) {
 	b := bu.get()
-	cmd := exec.Command(b.objdump, "-d", "-C", "--no-show-raw-insn", "-l",
+	args := []string{"-d", "-C", "--no-show-raw-insn", "-l",
 		fmt.Sprintf("--start-address=%#x", start),
-		fmt.Sprintf("--stop-address=%#x", end),
-		file)
+		fmt.Sprintf("--stop-address=%#x", end)}
+
+	if intelSyntax {
+		if runtime.GOOS == "darwin" {
+			args = append(args, "-x86-asm-syntax=intel")
+		} else {
+			args = append(args, "-M", "intel")
+		}
+	}
+
+	args = append(args, file)
+	cmd := exec.Command(b.objdump, args...)
 	out, err := cmd.Output()
 	if err != nil {
 		return nil, fmt.Errorf("%v: %v", cmd.Args, err)

internal/binutils/binutils_test.go

 	}
 }
 
-func TestDisasm(t *testing.T) {
-	skipUnlessLinuxAmd64(t)
+func testDisasm(t *testing.T, intelSyntax bool) {
 	bu := &Binutils{}
-	insts, err := bu.Disasm(filepath.Join("testdata", "exe_linux_64"), 0, math.MaxUint64)
+	insts, err := bu.Disasm(filepath.Join("testdata", "exe_linux_64"), 0, math.MaxUint64, intelSyntax)
 	if err != nil {
 		t.Fatalf("Disasm: unexpected error %v", err)
 	}
 	}
 }
 
+func TestDisasm(t *testing.T) {
+	skipUnlessLinuxAmd64(t)
+	testDisasm(t, true)
+	testDisasm(t, false)
+}
+
 func findSymbol(syms []*plugin.Sym, name string) *plugin.Sym {
 	for _, s := range syms {
 		for _, n := range s.Name {

internal/driver/commands.go

 	"compact_labels": &variable{boolKind, "f", "", "Show minimal headers"},
 	"source_path":    &variable{stringKind, "", "", "Search path for source files"},
 	"trim_path":      &variable{stringKind, "", "", "Path to trim from source paths before search"},
+	"intel_syntax": &variable{boolKind, "f", "", helpText(
+		"Show assembly in Intel syntax",
+		"Only applicable to commands `disasm` and `weblist`")},
 
 	// Filtering options
 	"nodecount": &variable{intKind, "-1", "", helpText(

internal/driver/driver.go

 
 		SourcePath: vars["source_path"].stringValue(),
 		TrimPath:   vars["trim_path"].stringValue(),
+
+		IntelSyntax: vars["intel_syntax"].boolValue(),
 	}
 
 	if len(p.Mapping) > 0 && p.Mapping[0].File != "" {

internal/driver/driver_test.go

 	return &mockFile{file, "abcdef", 0}, nil
 }
 
-func (m *mockObjTool) Disasm(file string, start, end uint64) ([]plugin.Inst, error) {
+func (m *mockObjTool) Disasm(file string, start, end uint64, intelSyntax bool) ([]plugin.Inst, error) {
 	switch start {
 	case 0x1000:
 		return []plugin.Inst{

internal/driver/fetch_test.go

 func (testObj) Demangler(_ string) func(names []string) (map[string]string, error) {
 	return func(names []string) (map[string]string, error) { return nil, nil }
 }
-func (testObj) Disasm(file string, start, end uint64) ([]plugin.Inst, error) { return nil, nil }
+func (testObj) Disasm(file string, start, end uint64, intelSyntax bool) ([]plugin.Inst, error) {
+	return nil, nil
+}
 
 type testFile struct{ name, buildID string }
 

internal/driver/webui_test.go

 	return fakeObj{}, nil
 }
 
-func (obj fakeObjTool) Disasm(file string, start, end uint64) ([]plugin.Inst, error) {
+func (obj fakeObjTool) Disasm(file string, start, end uint64, intelSyntax bool) ([]plugin.Inst, error) {
 	return []plugin.Inst{
 		{Addr: addrBase + 0, Text: "f1:asm", Function: "F1"},
 		{Addr: addrBase + 10, Text: "f2:asm", Function: "F2"},

internal/plugin/plugin.go

 
 	// Disasm disassembles the named object file, starting at
 	// the start address and stopping at (before) the end address.
-	Disasm(file string, start, end uint64) ([]Inst, error)
+	Disasm(file string, start, end uint64, intelSyntax bool) ([]Inst, error)
 }
 
 // An Inst is a single instruction in an assembly listing.

internal/report/report.go

 	Symbol     *regexp.Regexp // Symbols to include on disassembly report.
 	SourcePath string         // Search path for source files.
 	TrimPath   string         // Paths to trim from source file paths.
+
+	IntelSyntax bool // Whether or not to print assembly in Intel syntax.
 }
 
 // Generate generates a report as directed by the Report.
 		flatSum, cumSum := sns.Sum()
 
 		// Get the function assembly.
-		insts, err := obj.Disasm(s.sym.File, s.sym.Start, s.sym.End)
+		insts, err := obj.Disasm(s.sym.File, s.sym.Start, s.sym.End, o.IntelSyntax)
 		if err != nil {
 			return err
 		}

internal/report/source.go

 		ff := fileFunction{n.Info.File, n.Info.Name}
 		fns := fileNodes[ff]
 
-		asm := assemblyPerSourceLine(symbols, fns, ff.fileName, obj)
+		asm := assemblyPerSourceLine(symbols, fns, ff.fileName, obj, o.IntelSyntax)
 		start, end := sourceCoordinates(asm)
 
 		fnodes, path, err := getSourceFromFile(ff.fileName, reader, fns, start, end)
 // assemblyPerSourceLine disassembles the binary containing a symbol
 // and classifies the assembly instructions according to its
 // corresponding source line, annotating them with a set of samples.
-func assemblyPerSourceLine(objSyms []*objSymbol, rs graph.Nodes, src string, obj plugin.ObjTool) map[int][]assemblyInstruction {
+func assemblyPerSourceLine(objSyms []*objSymbol, rs graph.Nodes, src string, obj plugin.ObjTool, intelSyntax bool) map[int][]assemblyInstruction {
 	assembly := make(map[int][]assemblyInstruction)
 	// Identify symbol to use for this collection of samples.
 	o := findMatchingSymbol(objSyms, rs)
 	}
 
 	// Extract assembly for matched symbol
-	insts, err := obj.Disasm(o.sym.File, o.sym.Start, o.sym.End)
+	insts, err := obj.Disasm(o.sym.File, o.sym.Start, o.sym.End, intelSyntax)
 	if err != nil {
 		return assembly
 	}

internal/symbolizer/symbolizer_test.go

 	return mockObjFile{frames: mockAddresses}, nil
 }
 
-func (mockObjTool) Disasm(file string, start, end uint64) ([]plugin.Inst, error) {
+func (mockObjTool) Disasm(file string, start, end uint64, intelSyntax bool) ([]plugin.Inst, error) {
 	return nil, fmt.Errorf("disassembly not supported")
 }