Merge pull request #58 from rauls5382/disasm

Add source information to disassembly reports

driver/driver.go

 
 // An Inst is a single instruction in an assembly listing.
 type Inst struct {
-	Addr uint64 // virtual address of instruction
-	Text string // instruction text
-	File string // source file
-	Line int    // source line
+	Addr     uint64 // virtual address of instruction
+	Text     string // instruction text
+	Function string // function name
+	File     string // source file
+	Line     int    // source line
 }
 
 // An ObjFile is a single object file: a shared library or executable.

internal/binutils/disasm.go

 	nmOutputRE            = regexp.MustCompile(`^\s*([[:xdigit:]]+)\s+(.)\s+(.*)`)
 	objdumpAsmOutputRE    = regexp.MustCompile(`^\s*([[:xdigit:]]+):\s+(.*)`)
 	objdumpOutputFileLine = regexp.MustCompile(`^(.*):([0-9]+)`)
+	objdumpOutputFunction = regexp.MustCompile(`^(\S.*)\(\):`)
 )
 
 func findSymbols(syms []byte, file string, r *regexp.Regexp, address uint64) ([]*plugin.Sym, error) {
 // the assembly instructions in a slice.
 func disassemble(asm []byte) ([]plugin.Inst, error) {
 	buf := bytes.NewBuffer(asm)
-	file, line := "", 0
+	function, file, line := "", "", 0
 	var assembly []plugin.Inst
 	for {
 		input, err := buf.ReadString('\n')
 			if address, err := strconv.ParseUint(fields[1], 16, 64); err == nil {
 				assembly = append(assembly,
 					plugin.Inst{
-						Addr: address,
-						Text: fields[2],
-						File: file,
-						Line: line,
+						Addr:     address,
+						Text:     fields[2],
+						Function: function,
+						File:     file,
+						Line:     line,
 					})
 				continue
 			}
 			if l, err := strconv.ParseUint(fields[2], 10, 32); err == nil {
 				file, line = fields[1], int(l)
 			}
+			continue
+		}
+		if fields := objdumpOutputFunction.FindStringSubmatch(input); len(fields) == 2 {
+			function = fields[1]
+			continue
 		}
+		// Reset on unrecognized lines.
+		function, file, line = "", "", 0
 	}
 
 	return assembly, nil

internal/binutils/disasm_test.go

   1003: instruction four
 `,
 			[]plugin.Inst{
-				{0x1000, "instruction one", "", 0},
-				{0x1001, "instruction two", "", 0},
-				{0x1002, "instruction three", "", 0},
-				{0x1003, "instruction four", "", 0},
+				{Addr: 0x1000, Text: "instruction one"},
+				{Addr: 0x1001, Text: "instruction two"},
+				{Addr: 0x1002, Text: "instruction three"},
+				{Addr: 0x1003, Text: "instruction four"},
 			},
 		},
 		{
   2001: instruction two
 `,
 			[]plugin.Inst{
-				{0x2000, "instruction one", "", 0},
-				{0x2001, "instruction two", "", 0},
+				{Addr: 0x2000, Text: "instruction one"},
+				{Addr: 0x2001, Text: "instruction two"},
 			},
 		},
 	}
 	const objdump = "testdata/wrapper/objdump"
 
 	for _, tc := range testcases {
-		insns, err := disassemble([]byte(tc.asm))
+		insts, err := disassemble([]byte(tc.asm))
 		if err != nil {
 			t.Fatalf("FunctionAssembly: %v", err)
 		}
 
-		if len(insns) != len(tc.want) {
-			t.Errorf("Unexpected number of assembly instructions %d (want %d)\n", len(insns), len(tc.want))
+		if len(insts) != len(tc.want) {
+			t.Errorf("Unexpected number of assembly instructions %d (want %d)\n", len(insts), len(tc.want))
 		}
-		for i := range insns {
-			if insns[i] != tc.want[i] {
-				t.Errorf("Expected symbol %v, got %v\n", tc.want[i], insns[i])
+		for i := range insts {
+			if insts[i] != tc.want[i] {
+				t.Errorf("Expected symbol %v, got %v\n", tc.want[i], insts[i])
 			}
 		}
 	}

internal/driver/driver_test.go

 	switch start {
 	case 0x1000:
 		return []plugin.Inst{
-			{0x1000, "instruction one", "", 0},
-			{0x1001, "instruction two", "", 0},
-			{0x1002, "instruction three", "", 0},
-			{0x1003, "instruction four", "", 0},
+			{Addr: 0x1000, Text: "instruction one"},
+			{Addr: 0x1001, Text: "instruction two"},
+			{Addr: 0x1002, Text: "instruction three"},
+			{Addr: 0x1003, Text: "instruction four"},
 		}, nil
 	case 0x3000:
 		return []plugin.Inst{
-			{0x3000, "instruction one", "", 0},
-			{0x3001, "instruction two", "", 0},
-			{0x3002, "instruction three", "", 0},
-			{0x3003, "instruction four", "", 0},
-			{0x3004, "instruction five", "", 0},
+			{Addr: 0x3000, Text: "instruction one"},
+			{Addr: 0x3001, Text: "instruction two"},
+			{Addr: 0x3002, Text: "instruction three"},
+			{Addr: 0x3003, Text: "instruction four"},
+			{Addr: 0x3004, Text: "instruction five"},
 		}, nil
 	}
 	return nil, fmt.Errorf("unimplemented")

internal/driver/testdata/pprof.cpu.flat.addresses.disasm

 Total: 1.12s
 ROUTINE ======================== line1000
      1.10s      1.10s (flat, cum) 98.21% of Total
-     1.10s      1.10s       1000: instruction one
+     1.10s      1.10s       1000: instruction one                         ; line1000 file1000.src:1
          .          .       1001: instruction two
          .          .       1002: instruction three
          .          .       1003: instruction four
 ROUTINE ======================== line3000
       10ms      1.12s (flat, cum)   100% of Total
-      10ms      1.01s       3000: instruction one
-         .      100ms       3001: instruction two
-         .       10ms       3002: instruction three
+      10ms      1.01s       3000: instruction one                         ; line3000 file3000.src:6
+         .      100ms       3001: instruction two                         ; line3000 file3000.src:9
+         .       10ms       3002: instruction three                       ; line3000 file3000.src:7
          .          .       3003: instruction four
          .          .       3004: instruction five

internal/driver/testdata/pprof.cpu.flat.addresses.weblist

 Duration: 10s, Total samples = 1.12s (11.20%)<br>Total: 1.12s</div><h1>line1000</h1>testdata/file1000.src
 <pre onClick="pprof_toggle_asm(event)">
   Total:       1.10s      1.10s (flat, cum) 98.21%
-<span class=line>      1</span> <span class=deadsrc>       1.10s      1.10s line1 </span><span class=asm>               1.10s      1.10s     1000: instruction one                                  <span class=disasmloc>testdata/file1000.src:1</span>
+<span class=line>      1</span> <span class=deadsrc>       1.10s      1.10s line1 </span><span class=asm>               1.10s      1.10s     1000: instruction one                                  <span class=disasmloc>file1000.src:1</span>
                    .          .     1001: instruction two                                  <span class=disasmloc></span>
                    .          .     1002: instruction three                                <span class=disasmloc></span>
                    .          .     1003: instruction four                                 <span class=disasmloc></span>
 <span class=line>      3</span> <span class=nop>           .          . line3 </span>
 <span class=line>      4</span> <span class=nop>           .          . line4 </span>
 <span class=line>      5</span> <span class=nop>           .          . line5 </span>
-<span class=line>      6</span> <span class=deadsrc>        10ms      1.01s line6 </span><span class=asm>                10ms      1.01s     3000: instruction one                                  <span class=disasmloc>testdata/file3000.src:6</span>
+<span class=line>      6</span> <span class=deadsrc>        10ms      1.01s line6 </span><span class=asm>                10ms      1.01s     3000: instruction one                                  <span class=disasmloc>file3000.src:6</span>
 </span>
-<span class=line>      7</span> <span class=deadsrc>           .       10ms line7 </span><span class=asm>                   .       10ms     3002: instruction three                                <span class=disasmloc>testdata/file3000.src:7</span>
+<span class=line>      7</span> <span class=deadsrc>           .       10ms line7 </span><span class=asm>                   .       10ms     3002: instruction three                                <span class=disasmloc>file3000.src:7</span>
                    .          .     3003: instruction four                                 <span class=disasmloc></span>
                    .          .     3004: instruction five                                 <span class=disasmloc></span>
 </span>
 <span class=line>      8</span> <span class=nop>           .          . line8 </span>
-<span class=line>      9</span> <span class=deadsrc>           .      100ms line9 </span><span class=asm>                   .      100ms     3001: instruction two                                  <span class=disasmloc>testdata/file3000.src:9</span>
+<span class=line>      9</span> <span class=deadsrc>           .      100ms line9 </span><span class=asm>                   .      100ms     3001: instruction two                                  <span class=disasmloc>file3000.src:9</span>
 </span>
 <span class=line>     10</span> <span class=nop>           .          . line0 </span>
 <span class=line>     11</span> <span class=nop>           .          . line1 </span>

internal/plugin/plugin.go

 
 // An Inst is a single instruction in an assembly listing.
 type Inst struct {
-	Addr uint64 // virtual address of instruction
-	Text string // instruction text
-	File string // source file
-	Line int    // source line
+	Addr     uint64 // virtual address of instruction
+	Text     string // instruction text
+	Function string // function name
+	File     string // source file
+	Line     int    // source line
 }
 
 // An ObjFile is a single object file: a shared library or executable.

internal/report/report.go

 		flatSum, cumSum := sns.Sum()
 
 		// Get the function assembly.
-		insns, 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)
 		if err != nil {
 			return err
 		}
 
-		ns := annotateAssembly(insns, sns, s.base)
+		ns := annotateAssembly(insts, sns, s.base)
 
 		fmt.Fprintf(w, "ROUTINE ======================== %s\n", s.sym.Name[0])
 		for _, name := range s.sym.Name[1:] {
 			rpt.formatValue(flatSum), rpt.formatValue(cumSum),
 			percentage(cumSum, rpt.total))
 
+		function, file, line := "", "", 0
 		for _, n := range ns {
-			fmt.Fprintf(w, "%10s %10s %10x: %s\n", valueOrDot(n.FlatValue(), rpt), valueOrDot(n.CumValue(), rpt), n.Info.Address, n.Info.Name)
+			flat := valueOrDot(n.flatValue(), rpt)
+			cum := valueOrDot(n.cumValue(), rpt)
+			if n.function == function && n.file == file && n.line == line {
+				fmt.Fprintf(w, "%10s %10s %10x: %s\n",
+					flat, cum,
+					n.address, n.instruction,
+				)
+				continue
+			}
+			line := ""
+			if n.line > 0 {
+				line = fmt.Sprintf(":%d", n.line)
+			}
+			if len(n.instruction) <= 40 {
+				fmt.Fprintf(w, "%10s %10s %10x: %-40s; %s %s%s\n",
+					flat, cum,
+					n.address, n.instruction,
+					n.function, n.file, line,
+				)
+				continue
+			}
+			fmt.Fprintf(w, "%75s; %s %s%s\n",
+				"",
+				n.function, n.file, line,
+			)
+			fmt.Fprintf(w, "%10s %10s %10x: %s\n",
+				flat, cum,
+				n.address, n.instruction,
+			)
 		}
 	}
 	return nil
 	return symNodes
 }
 
+type assemblyInstruction struct {
+	address         uint64
+	instruction     string
+	function        string
+	file            string
+	line            int
+	flat, cum       int64
+	flatDiv, cumDiv int64
+}
+
+func (a *assemblyInstruction) flatValue() int64 {
+	if a.flatDiv != 0 {
+		return a.flat / a.flatDiv
+	}
+	return a.flat
+}
+
+func (a *assemblyInstruction) cumValue() int64 {
+	if a.cumDiv != 0 {
+		return a.cum / a.cumDiv
+	}
+	return a.cum
+}
+
 // annotateAssembly annotates a set of assembly instructions with a
 // set of samples. It returns a set of nodes to display. base is an
 // offset to adjust the sample addresses.
-func annotateAssembly(insns []plugin.Inst, samples graph.Nodes, base uint64) graph.Nodes {
+func annotateAssembly(insts []plugin.Inst, samples graph.Nodes, base uint64) []assemblyInstruction {
 	// Add end marker to simplify printing loop.
-	insns = append(insns, plugin.Inst{
+	insts = append(insts, plugin.Inst{
 		Addr: ^uint64(0),
 	})
 
 	// Ensure samples are sorted by address.
 	samples.Sort(graph.AddressOrder)
 
-	var s int
-	var asm graph.Nodes
-	for ix, in := range insns[:len(insns)-1] {
-		n := graph.Node{
-			Info: graph.NodeInfo{
-				Address: in.Addr,
-				Name:    in.Text,
-				File:    trimPath(in.File),
-				Lineno:  in.Line,
-			},
+	s := 0
+	asm := make([]assemblyInstruction, 0, len(insts))
+	for ix, in := range insts[:len(insts)-1] {
+		n := assemblyInstruction{
+			address:     in.Addr,
+			instruction: in.Text,
+			function:    in.Function,
+			line:        in.Line,
+		}
+		if in.File != "" {
+			n.file = filepath.Base(in.File)
 		}
 
 		// Sum all the samples until the next instruction (to account
 		// for samples attributed to the middle of an instruction).
-		for next := insns[ix+1].Addr; s < len(samples) && samples[s].Info.Address-base < next; s++ {
-			n.FlatDiv += samples[s].FlatDiv
-			n.Flat += samples[s].Flat
-			n.CumDiv += samples[s].CumDiv
-			n.Cum += samples[s].Cum
-			if samples[s].Info.File != "" {
-				n.Info.File = trimPath(samples[s].Info.File)
-				n.Info.Lineno = samples[s].Info.Lineno
+		for next := insts[ix+1].Addr; s < len(samples) && samples[s].Info.Address-base < next; s++ {
+			sample := samples[s]
+			n.flatDiv += sample.FlatDiv
+			n.flat += sample.Flat
+			n.cumDiv += sample.CumDiv
+			n.cum += sample.Cum
+			if f := sample.Info.File; f != "" && n.file == "" {
+				n.file = filepath.Base(f)
+			}
+			if ln := sample.Info.Lineno; ln != 0 && n.line == 0 {
+				n.line = ln
+			}
+			if f := sample.Info.Name; f != "" && n.function == "" {
+				n.function = f
 			}
 		}
-		asm = append(asm, &n)
+		asm = append(asm, n)
 	}
 
 	return asm

internal/report/source.go

 
 // sourceCoordinates returns the lowest and highest line numbers from
 // a set of assembly statements.
-func sourceCoordinates(asm map[int]graph.Nodes) (start, end int) {
+func sourceCoordinates(asm map[int][]assemblyInstruction) (start, end int) {
 	for l := range asm {
 		if start == 0 || l < start {
 			start = l
 // 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]graph.Nodes {
-	assembly := make(map[int]graph.Nodes)
+func assemblyPerSourceLine(objSyms []*objSymbol, rs graph.Nodes, src string, obj plugin.ObjTool) map[int][]assemblyInstruction {
+	assembly := make(map[int][]assemblyInstruction)
 	// Identify symbol to use for this collection of samples.
 	o := findMatchingSymbol(objSyms, rs)
 	if o == nil {
 	}
 
 	// Extract assembly for matched symbol
-	insns, 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)
 	if err != nil {
 		return assembly
 	}
 
 	srcBase := filepath.Base(src)
-	anodes := annotateAssembly(insns, rs, o.base)
+	anodes := annotateAssembly(insts, rs, o.base)
 	var lineno = 0
 	for _, an := range anodes {
-		if filepath.Base(an.Info.File) == srcBase {
-			lineno = an.Info.Lineno
+		if filepath.Base(an.file) == srcBase {
+			lineno = an.line
 		}
 		if lineno != 0 {
 			assembly[lineno] = append(assembly[lineno], an)
 }
 
 // printFunctionSourceLine prints a source line and the corresponding assembly.
-func printFunctionSourceLine(w io.Writer, fn *graph.Node, assembly graph.Nodes, rpt *Report) {
+func printFunctionSourceLine(w io.Writer, fn *graph.Node, assembly []assemblyInstruction, rpt *Report) {
 	if len(assembly) == 0 {
 		fmt.Fprintf(w,
 			"<span class=line> %6d</span> <span class=nop>  %10s %10s %s </span>\n",
 	for _, an := range assembly {
 		var fileline string
 		class := "disasmloc"
-		if an.Info.File != "" {
-			fileline = fmt.Sprintf("%s:%d", template.HTMLEscapeString(an.Info.File), an.Info.Lineno)
-			if an.Info.Lineno != fn.Info.Lineno {
+		if an.file != "" {
+			fileline = fmt.Sprintf("%s:%d", template.HTMLEscapeString(an.file), an.line)
+			if an.line != fn.Info.Lineno {
 				class = "unimportant"
 			}
 		}
+		flat, cum := an.flat, an.cum
+		if an.flatDiv != 0 {
+			flat = flat / an.flatDiv
+		}
+		if an.cumDiv != 0 {
+			cum = cum / an.cumDiv
+		}
 		fmt.Fprintf(w, " %8s %10s %10s %8x: %-48s <span class=%s>%s</span>\n", "",
-			valueOrDot(an.Flat, rpt), valueOrDot(an.Cum, rpt),
-			an.Info.Address,
-			template.HTMLEscapeString(an.Info.Name),
+			valueOrDot(flat, rpt), valueOrDot(cum, rpt),
+			an.address,
+			template.HTMLEscapeString(an.instruction),
 			class,
 			template.HTMLEscapeString(fileline))
 	}
 
 // getMissingFunctionSource creates a dummy function body to point to
 // the source file and annotates it with the samples in asm.
-func getMissingFunctionSource(filename string, asm map[int]graph.Nodes, start, end int) (graph.Nodes, string) {
+func getMissingFunctionSource(filename string, asm map[int][]assemblyInstruction, start, end int) (graph.Nodes, string) {
 	var fnodes graph.Nodes
 	for i := start; i <= end; i++ {
-		lrs := asm[i]
-		if len(lrs) == 0 {
+		insts := asm[i]
+		if len(insts) == 0 {
 			continue
 		}
-		flat, cum := lrs.Sum()
+		var group assemblyInstruction
+		for _, insn := range insts {
+			group.flat += insn.flat
+			group.cum += insn.cum
+			group.flatDiv += insn.flatDiv
+			group.cumDiv += insn.cumDiv
+		}
+		flat := group.flatValue()
+		cum := group.cumValue()
 		fnodes = append(fnodes, &graph.Node{
 			Info: graph.NodeInfo{
 				Name:   "???",