Improve weblist assembly output (#124)

* Align file names in weblist disassembly

The disassembly displayed by weblist attempts to align file:line
information after each instruction, but two things interfere with this
alignment: 1) the instruction text often has tabs in it, which defeats
the length-based alignment and generally interacts poorly with HTML
rendering and 2) the instruction text often has special HTML
characters like < and > in it, but we pad the string after escaping
it, so the length is again not representative of how it will display.
For example, the following shows what this looks like for disassembly
that contains < and >:

                   .          .   41c634: cmp    $0x200,%rdx                               mgcsweepbuf.go:130
                   .          .   41c63b: jae    41c64f <runtime.(*gcSweepBuf).pop+0x4f> mgcsweepbuf.go:130
                   .          .   41c63d: mov    (%rax,%rdx,8),%rcx                        mgcsweepbuf.go:130
                   .          .   41c64f: callq  424800 <runtime.panicindex>             mgcsweepbuf.go:130
                   .          .   41c654: ud2                                              mgcsweepbuf.go:130

Fix these problems by replacing tab characters with spaces and padding
the string before escaping it. After this, the file names are properly
aligned:

                   .          .   41c634: cmp    $0x200,%rdx                               mgcsweepbuf.go:130
                   .          .   41c63b: jae    41c64f <runtime.(*gcSweepBuf).pop+0x4f>   mgcsweepbuf.go:130
                   .          .   41c63d: mov    (%rax,%rdx,8),%rcx                        mgcsweepbuf.go:130
                   .          .   41c64f: callq  424800 <runtime.panicindex>               mgcsweepbuf.go:130
                   .          .   41c654: ud2                                              mgcsweepbuf.go:130

* Separate discontiguous assembly blocks

Currently, weblist's disassembled output for each line simply lists
all instructions that are marked with that line number. This leads to
confusing disassembly because a lot of things look like straight-line
control flow when they aren't. For example, index panics look like
they always happen:

   .          .   41c62c: test   %al,(%rax)
   .          .   41c62e: and    $0x1ff,%edx
   .          .   41c634: cmp    $0x200,%rdx
   .          .   41c63b: jae    41c64f <runtime.(*gcSweepBuf).pop+0x4f>
   .          .   41c63d: mov    (%rax,%rdx,8),%rcx
   .          .   41c64f: callq  424800 <runtime.panicindex>
   .          .   41c654: ud2

In reality, 41c64f is at the end of the function, but it looks like we
call it immediately after a successful index operation.

Fix this by adding a vertical ellipses to separate blocks of assembly
that have other instructions between them. With this change, the above
looks like:

   .          .   41c62c: test   %al,(%rax)
   .          .   41c62e: and    $0x1ff,%edx
   .          .   41c634: cmp    $0x200,%rdx
   .          .   41c63b: jae    41c64f <runtime.(*gcSweepBuf).pop+0x4f>
   .          .   41c63d: mov    (%rax,%rdx,8),%rcx
                       ⋮
   .          .   41c64f: callq  424800 <runtime.panicindex>
   .          .   41c654: ud2

internal/driver/driver_test.go

 	switch start {
 	case 0x1000:
 		return []plugin.Inst{
-			{Addr: 0x1000, Text: "instruction one"},
-			{Addr: 0x1001, Text: "instruction two"},
-			{Addr: 0x1002, Text: "instruction three"},
-			{Addr: 0x1003, Text: "instruction four"},
+			{Addr: 0x1000, Text: "instruction one", File: "file1000.src", Line: 1},
+			{Addr: 0x1001, Text: "instruction two", File: "file1000.src", Line: 1},
+			{Addr: 0x1002, Text: "instruction three", File: "file1000.src", Line: 2},
+			{Addr: 0x1003, Text: "instruction four", File: "file1000.src", Line: 1},
 		}, nil
 	case 0x3000:
 		return []plugin.Inst{

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

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

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

 <!DOCTYPE html>
 <html>
 <head>
+<meta charset="UTF-8">
 <title>Pprof listing</title>
 <style type="text/css">
 body {
 <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>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>
+                   .          .     1001: instruction two                                  <span class=disasmloc>file1000.src:1</span>
+                                       ⋮
+                   .          .     1003: instruction four                                 <span class=disasmloc>file1000.src:1</span>
+</span>
+<span class=line>      2</span> <span class=deadsrc>           .          . line2 </span><span class=asm>                   .          .     1002: instruction three                                <span class=disasmloc>file1000.src:2</span>
 </span>
-<span class=line>      2</span> <span class=nop>           .          . line2 </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=nop>           .          . line6 </span>
+<span class=line>      7</span> <span class=nop>           .          . line7 </span>
 </pre>
 <h1>line3000</h1>testdata/file3000.src
 <pre onClick="pprof_toggle_asm(event)">

internal/report/report.go

 	line            int
 	flat, cum       int64
 	flatDiv, cumDiv int64
+	startsBlock     bool
 }
 
 func (a *assemblyInstruction) flatValue() int64 {

internal/report/source.go

 	srcBase := filepath.Base(src)
 	anodes := annotateAssembly(insts, rs, o.base)
 	var lineno = 0
+	var prevline = 0
 	for _, an := range anodes {
 		if filepath.Base(an.file) == srcBase {
 			lineno = an.line
 		}
 		if lineno != 0 {
+			if lineno != prevline {
+				// This instruction starts a new block
+				// of contiguous instructions on this line.
+				an.startsBlock = true
+			}
+			prevline = lineno
 			assembly[lineno] = append(assembly[lineno], an)
 		}
 	}
 		valueOrDot(fn.Flat, rpt), valueOrDot(fn.Cum, rpt),
 		template.HTMLEscapeString(fn.Info.Name))
 	fmt.Fprint(w, "<span class=asm>")
-	for _, an := range assembly {
+	for i, an := range assembly {
+		if an.startsBlock && i != 0 {
+			// Insert a separator between discontiguous blocks.
+			fmt.Fprintf(w, " %8s %30s\n", "", "⋮")
+		}
+
 		var fileline string
 		class := "disasmloc"
 		if an.file != "" {
 		if an.cumDiv != 0 {
 			cum = cum / an.cumDiv
 		}
-		fmt.Fprintf(w, " %8s %10s %10s %8x: %-48s <span class=%s>%s</span>\n", "",
+		fmt.Fprintf(w, " %8s %10s %10s %8x: %s <span class=%s>%s</span>\n", "",
 			valueOrDot(flat, rpt), valueOrDot(cum, rpt),
 			an.address,
-			template.HTMLEscapeString(an.instruction),
+			template.HTMLEscapeString(fmt.Sprintf("%-48s", strings.Replace(an.instruction, "\t", " ", -1))),
 			class,
 			template.HTMLEscapeString(fileline))
 	}

internal/report/source_html.go

 <!DOCTYPE html>
 <html>
 <head>
+<meta charset="UTF-8">
 <title>Pprof listing</title>
 <style type="text/css">
 body {