Merge pull request #1 from google/nowrapper

remove binutils wrappers used for testing

internal/binutils/addr2liner.go

 	sentinel = ^uint64(0)
 )
 
-// Addr2Liner is a connection to an addr2line command for obtaining
+// addr2Liner is a connection to an addr2line command for obtaining
 // address and line number information from a binary.
 type addr2Liner struct {
-	filename string
-	cmd      *exec.Cmd
-	in       io.WriteCloser
-	out      *bufio.Reader
-	err      error
-
+	rw   lineReaderWriter
 	base uint64
 }
 
+// lineReaderWriter is an interface to abstract the I/O to an addr2line
+// process. It writes a line of input to the job, and reads its output
+// one line at a time.
+type lineReaderWriter interface {
+	write(string) error
+	readLine() (string, error)
+	close()
+}
+
+type addr2LinerJob struct {
+	cmd *exec.Cmd
+	in  io.WriteCloser
+	out *bufio.Reader
+}
+
+func (a *addr2LinerJob) write(s string) error {
+	_, err := fmt.Fprint(a.in, s+"\n")
+	return err
+}
+
+func (a *addr2LinerJob) readLine() (string, error) {
+	return a.out.ReadString('\n')
+}
+
+// close releases any resources used by the addr2liner object.
+func (a *addr2LinerJob) close() {
+	a.in.Close()
+	a.cmd.Wait()
+}
+
 // newAddr2liner starts the given addr2liner command reporting
 // information about the given executable file. If file is a shared
 // library, base should be the address at which is was mapped in the
 		cmd = defaultAddr2line
 	}
 
-	a := &addr2Liner{
-		filename: file,
-		base:     base,
-		cmd:      exec.Command(cmd, "-aif", "-e", file),
+	j := &addr2LinerJob{
+		cmd: exec.Command(cmd, "-aif", "-e", file),
 	}
 
 	var err error
-	if a.in, err = a.cmd.StdinPipe(); err != nil {
+	if j.in, err = j.cmd.StdinPipe(); err != nil {
 		return nil, err
 	}
 
-	outPipe, err := a.cmd.StdoutPipe()
+	outPipe, err := j.cmd.StdoutPipe()
 	if err != nil {
 		return nil, err
 	}
 
-	a.out = bufio.NewReader(outPipe)
-	if err := a.cmd.Start(); err != nil {
+	j.out = bufio.NewReader(outPipe)
+	if err := j.cmd.Start(); err != nil {
 		return nil, err
 	}
-	return a, nil
-}
 
-// close releases any resources used by the addr2liner object.
-func (d *addr2Liner) close() {
-	d.in.Close()
-	d.cmd.Wait()
+	a := &addr2Liner{
+		rw:   j,
+		base: base,
+	}
+
+	return a, nil
 }
 
-func (d *addr2Liner) readString() (s string) {
-	if d.err != nil {
-		return ""
-	}
-	if s, d.err = d.out.ReadString('\n'); d.err != nil {
-		return ""
+func (d *addr2Liner) readString() (string, error) {
+	s, err := d.rw.readLine()
+	if err != nil {
+		return "", err
 	}
-	return strings.TrimSpace(s)
+	return strings.TrimSpace(s), nil
 }
 
 // readFrame parses the addr2line output for a single address. It
 // returns a populated plugin.Frame and whether it has reached the end of the
 // data.
 func (d *addr2Liner) readFrame() (plugin.Frame, bool) {
-	funcname := d.readString()
-
+	funcname, err := d.readString()
+	if err != nil {
+		return plugin.Frame{}, true
+	}
 	if strings.HasPrefix(funcname, "0x") {
 		// If addr2line returns a hex address we can assume it is the
 		// sentinel.  Read and ignore next two lines of output from
 		return plugin.Frame{}, true
 	}
 
-	fileline := d.readString()
-	if d.err != nil {
+	fileline, err := d.readString()
+	if err != nil {
 		return plugin.Frame{}, true
 	}
 
 // addrInfo returns the stack frame information for a specific program
 // address. It returns nil if the address could not be identified.
 func (d *addr2Liner) addrInfo(addr uint64) ([]plugin.Frame, error) {
-	if d.err != nil {
-		return nil, d.err
-	}
-
-	if _, d.err = fmt.Fprintf(d.in, "%x\n", addr-d.base); d.err != nil {
-		return nil, d.err
+	if err := d.rw.write(fmt.Sprintf("%x", addr-d.base)); err != nil {
+		return nil, err
 	}
 
-	if _, d.err = fmt.Fprintf(d.in, "%x\n", sentinel); d.err != nil {
-		return nil, d.err
+	if err := d.rw.write(fmt.Sprintf("%x", sentinel)); err != nil {
+		return nil, err
 	}
 
-	resp := d.readString()
-	if d.err != nil {
-		return nil, d.err
+	resp, err := d.readString()
+	if err != nil {
+		return nil, err
 	}
 
 	if !strings.HasPrefix(resp, "0x") {
-		d.err = fmt.Errorf("unexpected addr2line output: %s", resp)
-		return nil, d.err
+		return nil, fmt.Errorf("unexpected addr2line output: %s", resp)
 	}
 
 	var stack []plugin.Frame
 			stack = append(stack, frame)
 		}
 	}
-	return stack, d.err
+	return stack, nil
 }

internal/binutils/binutils.go

 		// Update the command invocations if not initialized.
 		b.SetTools("")
 	}
-	return disassemble(b.objdump, file, start, end)
+	cmd := exec.Command(b.objdump, "-d", "-C", "--no-show-raw-insn", "-l",
+		fmt.Sprintf("--start-address=%#x", start),
+		fmt.Sprintf("--stop-address=%#x", end),
+		file)
+	out, err := cmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("%v: %v", cmd.Args, err)
+	}
+
+	return disassemble(out)
 }
 
 // Open satisfies the plugin.ObjTool interface.
 }
 
 func (f *file) Symbols(r *regexp.Regexp, addr uint64) ([]*plugin.Sym, error) {
-	return findSymbols(f.b.nm, f.name, r, addr)
+	// Get from nm a list of symbols sorted by address.
+	cmd := exec.Command(f.b.nm, "-n", f.name)
+	out, err := cmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("%v: %v", cmd.Args, err)
+	}
+
+	return findSymbols(out, f.name, r, addr)
 }
 
 // fileNM implements the binutils.ObjFile interface, using 'nm' to map
 
 func (f *fileAddr2Line) Close() error {
 	if f.addr2liner != nil {
-		f.addr2liner.close()
+		f.addr2liner.rw.close()
 		f.addr2liner = nil
 	}
 	return nil

internal/binutils/binutils_test.go

 func TestAddr2Liner(t *testing.T) {
 	const offset = 0x500
 
-	a, err := newAddr2Liner("testdata/wrapper/addr2line", "executable", offset)
-	if err != nil {
-		t.Fatalf("Addr2Liner Open: %v", err)
-	}
-
+	a := addr2Liner{&mockAddr2liner{}, offset}
 	for i := 1; i < 8; i++ {
 		addr := i*0x1000 + offset
 		s, err := a.addrInfo(uint64(addr))
 	if len(s) != 0 {
 		t.Fatalf("AddrInfo(0xFFFF): got len==%d, want 0", len(s))
 	}
-	a.close()
+	a.rw.close()
+}
+
+type mockAddr2liner struct {
+	output []string
+}
+
+func (a *mockAddr2liner) write(s string) error {
+	var lines []string
+	switch s {
+	case "1000":
+		lines = []string{"_Z3fooid.clone2", "file1000:1000"}
+	case "2000":
+		lines = []string{"_ZNSaIiEC1Ev.clone18", "file2000:2000", "_Z3fooid.clone2", "file1000:1000"}
+	case "3000":
+		lines = []string{"_ZNSt6vectorIS_IS_IiSaIiEESaIS1_EESaIS3_EEixEm", "file3000:3000", "_ZNSaIiEC1Ev.clone18", "file2000:2000", "_Z3fooid.clone2", "file1000:1000"}
+	case "4000":
+		lines = []string{"fun4000", "file4000:4000", "_ZNSt6vectorIS_IS_IiSaIiEESaIS1_EESaIS3_EEixEm", "file3000:3000", "_ZNSaIiEC1Ev.clone18", "file2000:2000", "_Z3fooid.clone2", "file1000:1000"}
+	case "5000":
+		lines = []string{"fun5000", "file5000:5000", "fun4000", "file4000:4000", "_ZNSt6vectorIS_IS_IiSaIiEESaIS1_EESaIS3_EEixEm", "file3000:3000", "_ZNSaIiEC1Ev.clone18", "file2000:2000", "_Z3fooid.clone2", "file1000:1000"}
+	case "6000":
+		lines = []string{"fun6000", "file6000:6000", "fun5000", "file5000:5000", "fun4000", "file4000:4000", "_ZNSt6vectorIS_IS_IiSaIiEESaIS1_EESaIS3_EEixEm", "file3000:3000", "_ZNSaIiEC1Ev.clone18", "file2000:2000", "_Z3fooid.clone2", "file1000:1000"}
+	case "7000":
+		lines = []string{"fun7000", "file7000:7000", "fun6000", "file6000:6000", "fun5000", "file5000:5000", "fun4000", "file4000:4000", "_ZNSt6vectorIS_IS_IiSaIiEESaIS1_EESaIS3_EEixEm", "file3000:3000", "_ZNSaIiEC1Ev.clone18", "file2000:2000", "_Z3fooid.clone2", "file1000:1000"}
+	case "8000":
+		lines = []string{"fun8000", "file8000:8000", "fun7000", "file7000:7000", "fun6000", "file6000:6000", "fun5000", "file5000:5000", "fun4000", "file4000:4000", "_ZNSt6vectorIS_IS_IiSaIiEESaIS1_EESaIS3_EEixEm", "file3000:3000", "_ZNSaIiEC1Ev.clone18", "file2000:2000", "_Z3fooid.clone2", "file1000:1000"}
+	case "9000":
+		lines = []string{"fun9000", "file9000:9000", "fun8000", "file8000:8000", "fun7000", "file7000:7000", "fun6000", "file6000:6000", "fun5000", "file5000:5000", "fun4000", "file4000:4000", "_ZNSt6vectorIS_IS_IiSaIiEESaIS1_EESaIS3_EEixEm", "file3000:3000", "_ZNSaIiEC1Ev.clone18", "file2000:2000", "_Z3fooid.clone2", "file1000:1000"}
+	default:
+		lines = []string{"??", "??:0"}
+	}
+	a.output = append(a.output, "0x"+s)
+	a.output = append(a.output, lines...)
+	return nil
+}
+
+func (a *mockAddr2liner) readLine() (string, error) {
+	if len(a.output) == 0 {
+		return "", fmt.Errorf("end of file")
+	}
+	next := a.output[0]
+	a.output = a.output[1:]
+	return next, nil
+}
+
+func (a *mockAddr2liner) close() {
 }
 
 func TestAddr2LinerLookup(t *testing.T) {

internal/binutils/disasm.go

 
 import (
 	"bytes"
-	"fmt"
 	"io"
-	"os/exec"
 	"regexp"
 	"strconv"
 
 	objdumpOutputFileLine = regexp.MustCompile(`^(.*):([0-9]+)`)
 )
 
-func findSymbols(nm, file string, r *regexp.Regexp, address uint64) ([]*plugin.Sym, error) {
-	// Get from nm a list of symbols sorted by address.
-	cmd := exec.Command(nm, "-n", file)
-	out, err := cmd.Output()
-	if err != nil {
-		return nil, fmt.Errorf("%v: %v", cmd.Args, err)
-	}
-
+func findSymbols(syms []byte, file string, r *regexp.Regexp, address uint64) ([]*plugin.Sym, error) {
 	// Collect all symbols from the nm output, grouping names mapped to
 	// the same address into a single symbol.
 	var symbols []*plugin.Sym
 	names, start := []string{}, uint64(0)
-	buf := bytes.NewBuffer(out)
+	buf := bytes.NewBuffer(syms)
 	for symAddr, name, err := nextSymbol(buf); err == nil; symAddr, name, err = nextSymbol(buf) {
 		if err != nil {
 			return nil, err
 	return nil
 }
 
-// disassemble returns the assembly instructions in a function from a
-// binary file. It uses objdump to obtain the assembly listing.
-func disassemble(objdump string, file string, start, stop uint64) ([]plugin.Inst, error) {
-	cmd := exec.Command(objdump, "-d", "-C", "--no-show-raw-insn", "-l",
-		fmt.Sprintf("--start-address=%#x", start),
-		fmt.Sprintf("--stop-address=%#x", stop),
-		file)
-	out, err := cmd.Output()
-	if err != nil {
-		return nil, fmt.Errorf("%v: %v", cmd.Args, err)
-	}
-
-	buf := bytes.NewBuffer(out)
+// disassemble parses the output of the objdump command and returns
+// the assembly instructions in a slice.
+func disassemble(asm []byte) ([]plugin.Inst, error) {
+	buf := bytes.NewBuffer(asm)
 	file, line := "", 0
 	var assembly []plugin.Inst
 	for {

internal/binutils/disasm_test.go

 	"github.com/google/pprof/internal/plugin"
 )
 
-// TestFindSymbols tests the FindSymbols routine by using a fake nm
-// script.
+// TestFindSymbols tests the FindSymbols routine using a hardcoded nm output.
 func TestFindSymbols(t *testing.T) {
 	type testcase struct {
-		query string
-		want  []plugin.Sym
+		query, syms string
+		want        []plugin.Sym
 	}
 
+	testsyms := `0000000000001000 t lineA001
+0000000000001000 t lineA002
+0000000000001000 t line1000
+0000000000002000 t line200A
+0000000000002000 t line2000
+0000000000002000 t line200B
+0000000000003000 t line3000
+0000000000003000 t _ZNK4DumbclEPKc
+0000000000003000 t lineB00C
+0000000000003000 t line300D
+0000000000004000 t _the_end
+	`
 	testcases := []testcase{
 		{
 			"line.*[AC]",
+			testsyms,
 			[]plugin.Sym{
 				{[]string{"lineA001"}, "object.o", 0x1000, 0x1FFF},
 				{[]string{"line200A"}, "object.o", 0x2000, 0x2FFF},
 		},
 		{
 			"Dumb::operator",
+			testsyms,
 			[]plugin.Sym{
 				{[]string{"Dumb::operator()(char const*) const"}, "object.o", 0x3000, 0x3FFF},
 			},
 		},
 	}
 
-	const nm = "testdata/wrapper/nm"
 	for _, tc := range testcases {
-		syms, err := findSymbols(nm, "object.o", regexp.MustCompile(tc.query), 0)
+		syms, err := findSymbols([]byte(tc.syms), "object.o", regexp.MustCompile(tc.query), 0)
 		if err != nil {
 			t.Fatalf("%q: findSymbols: %v", tc.query, err)
 		}
 func TestFunctionAssembly(t *testing.T) {
 	type testcase struct {
 		s    plugin.Sym
+		asm  string
 		want []plugin.Inst
 	}
 	testcases := []testcase{
 		{
 			plugin.Sym{[]string{"symbol1"}, "", 0x1000, 0x1FFF},
+			`  1000: instruction one
+  1001: instruction two
+  1002: instruction three
+  1003: instruction four
+`,
 			[]plugin.Inst{
 				{0x1000, "instruction one", "", 0},
 				{0x1001, "instruction two", "", 0},
 		},
 		{
 			plugin.Sym{[]string{"symbol2"}, "", 0x2000, 0x2FFF},
+			`  2000: instruction one
+  2001: instruction two
+`,
 			[]plugin.Inst{
 				{0x2000, "instruction one", "", 0},
 				{0x2001, "instruction two", "", 0},
 	const objdump = "testdata/wrapper/objdump"
 
 	for _, tc := range testcases {
-		insns, err := disassemble(objdump, "object.o", tc.s.Start, tc.s.End)
+		insns, err := disassemble([]byte(tc.asm))
 		if err != nil {
 			t.Fatalf("FunctionAssembly: %v", err)
 		}

internal/binutils/testdata/wrapper/addr2line

-#!/bin/bash
-# Copyright 2014 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# addr2line stub for testing of addr2liner.
-# Will recognize (and ignore) the -aiCfej options.
-#
-# Accepts addresses 1000 to 9000 and output multiple frames of the form:
-#   0x9000/fun9000/file9000:9000
-#   0x8000/fun8000/file8000:8000
-#   0x7000/fun7000/file7000:7000
-#   ...
-#   0x1000/fun1000/file1000:1000
-#
-# Returns ??/??/??:0 for all other inputs.
-
-while getopts aiCfe:j: opt; do
-  case "$opt" in
-    a|i|C|f|e|j) ;;
-    *)
-      echo "unrecognized option: $1" >&2
-      exit 1
-  esac
-done
-
-while read input
-do
-  address="$input"
-  
-  # remove 0x from input.
-  case "${address}" in
-    0x*)
-      address=$(printf '%x' "$address")
-      ;;
-    *)
-      address=$(printf '%x' "0x$address")
-  esac
-
-  printf '0x%x\n' "0x$address"
-  loop=1
-  while [ $loop -eq 1 ]
-  do
-    # prepare default output.
-    output2="fun${address}"
-    output3="file${address}:${address}"
-
-    # specialize output for selected cases.
-	  case "${address}" in
-      1000)
-        output2="_Z3fooid.clone2"
-        loop=0
-        ;;
-      2000)
-        output2="_ZNSaIiEC1Ev.clone18"
-        address=1000
-        ;;
-      3000)
-        output2="_ZNSt6vectorIS_IS_IiSaIiEESaIS1_EESaIS3_EEixEm"
-        address=2000
-        ;;
-      [4-9]000)
-        address=$(expr ${address} - 1000)
-        ;;
-      *)
-        output2='??'
-        output3='??:0'
-        loop=0
-    esac
-
-    echo "$output2"
-    echo "$output3"
-  done
-done
-exit 0

internal/binutils/testdata/wrapper/nm

-#!/bin/bash
-# Copyright 2014 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# nm stub for testing of listing.
-# Will recognize (and ignore) the -nC options.
-#
-# Outputs fixed nm output.
-
-while getopts nC opt; do
-  case "$opt" in
-    n) ;;
-    C) demangle=1;;
-    *)
-      echo "unrecognized option: $1" >&2
-      exit 1
-  esac
-done
-
-if [ $demangle ] 
-then
-  cat <<EOF
-0000000000001000 t lineA001
-0000000000001000 t lineA002
-0000000000001000 t line1000
-0000000000002000 t line200A
-0000000000002000 t line2000
-0000000000002000 t line200B
-0000000000003000 t line3000
-0000000000003000 t Dumb::operator()(char const*) const
-0000000000003000 t lineB00C
-0000000000003000 t line300D
-0000000000004000 t _the_end
-EOF
-  exit 0
-fi
-
-cat <<EOF
-0000000000001000 t lineA001
-0000000000001000 t lineA002
-0000000000001000 t line1000
-0000000000002000 t line200A
-0000000000002000 t line2000
-0000000000002000 t line200B
-0000000000003000 t line3000
-0000000000003000 t _ZNK4DumbclEPKc
-0000000000003000 t lineB00C
-0000000000003000 t line300D
-0000000000004000 t _the_end
-EOF
-exit 0

internal/binutils/testdata/wrapper/objdump

-#!/bin/bash
-# Copyright 2014 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# objdump stub for testing of listing.
-# Will recognize (and ignore) the -nC options.
-#
-# Outputs fixed nm output.
-
-START=0
-STOP=0
-while [ $# -gt 1 ] ; do 
- case "$1" in 
-   --start-address=*) START=$(echo $1 | sed 's/.*=//') ;;
-   --stop-address=*) STOP=$(echo $1 | sed 's/.*=//') ;; 
-   --no-show-raw-insn|-d|-C|-n|-l) ;;
-   *) echo "Unrecognized option $1"
-     exit 1
- esac
- shift
-done
-
-case "$START$STOP" in 
-  "0x10000x1fff")
-  cat <<EOF
-  1000: instruction one
-  1001: instruction two
-  1002: instruction three
-  1003: instruction four
-EOF
-  ;;
-  "0x20000x2fff")
-  cat <<EOF
-  2000: instruction one
-  2001: instruction two
-EOF
-  ;;
-  "0x30000x3fff")
-  cat <<EOF
-  3000: instruction one
-  3001: instruction two
-  3002: instruction three
-  3003: instruction four
-  3004: instruction five
-EOF
-  ;;
-esac
-exit 0

internal/driver/driver_test.go

 	"bytes"
 	"fmt"
 	"io/ioutil"
-	"os"
+	"regexp"
 	"strconv"
 	"strings"
 	"testing"
 	"time"
 
-	"github.com/google/pprof/internal/binutils"
 	"github.com/google/pprof/internal/plugin"
 	"github.com/google/pprof/internal/proftest"
 	"github.com/google/pprof/internal/symbolz"
 	// Override weblist command to collect output in buffer
 	pprofCommands["weblist"].postProcess = nil
 
-	// Update PATH to use fake dot for svg output
-	os.Setenv("PATH", "testdata/wrapper"+":"+os.Getenv("PATH"))
-
 	testcase := []struct {
 		flags, source string
 	}{
 		{"dot,lines,flat,focus=[12]00", "heap"},
 		{"dot,addresses,flat,ignore=[X3]002,focus=[X1]000", "contention"},
 		{"dot,files,cum", "contention"},
-		{"svg", "cpu"},
 		{"tags", "cpu"},
 		{"tags,tagignore=tag[13],tagfocus=key[12]", "cpu"},
 		{"traces", "cpu"},
 		o2 := setDefaults(nil)
 		o2.Flagset = f
 		o2.Sym = testSymbolizeDemangler{}
-		o2.Obj = new(binutils.Binutils)
+		o2.Obj = new(mockObjTool)
 
 		if err := PProf(o2); err != nil {
 			t.Errorf("%s: %v", tc.source, err)
 			"divide_by":    1.0,
 		},
 		strings: map[string]string{
-			"tools": "testdata/wrapper",
-			"unit":  "minimum",
+			"unit": "minimum",
 		},
 	}
 }
 
 	o := setDefaults(nil)
 	o.Flagset = f
-	o.Obj = new(binutils.Binutils)
+	o.Obj = new(mockObjTool)
 	src, cmd, err := parseFlags(o)
 	if err != nil {
 		t.Fatalf("parseFlags: %v", err)
 		}
 	}
 }
+
+type mockObjTool struct{}
+
+func (*mockObjTool) Open(file string, start, limit, offset uint64) (plugin.ObjFile, error) {
+	return &mockFile{file, "abcdef", 0}, nil
+}
+
+func (m *mockObjTool) Disasm(file string, start, end uint64) ([]plugin.Inst, error) {
+	switch start {
+	case 0x1000:
+		return []plugin.Inst{
+			{0x1000, "instruction one", "", 0},
+			{0x1001, "instruction two", "", 0},
+			{0x1002, "instruction three", "", 0},
+			{0x1003, "instruction four", "", 0},
+		}, 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},
+		}, nil
+	}
+	return nil, fmt.Errorf("unimplemented")
+}
+
+type mockFile struct {
+	name, buildId string
+	base          uint64
+}
+
+// Name returns the underlyinf file name, if available
+func (m *mockFile) Name() string {
+	return m.name
+}
+
+// Base returns the base address to use when looking up symbols in the file.
+func (m *mockFile) Base() uint64 {
+	return m.base
+}
+
+// BuildID returns the GNU build ID of the file, or an empty string.
+func (m *mockFile) BuildID() string {
+	return m.buildId
+}
+
+// SourceLine reports the source line information for a given
+// address in the file. Due to inlining, the source line information
+// is in general a list of positions representing a call stack,
+// with the leaf function first.
+func (*mockFile) SourceLine(addr uint64) ([]plugin.Frame, error) {
+	return nil, fmt.Errorf("unimplemented")
+}
+
+// Symbols returns a list of symbols in the object file.
+// If r is not nil, Symbols restricts the list to symbols
+// with names matching the regular expression.
+// If addr is not zero, Symbols restricts the list to symbols
+// containing that address.
+func (m *mockFile) Symbols(r *regexp.Regexp, addr uint64) ([]*plugin.Sym, error) {
+	switch r.String() {
+	case "line[13]":
+		return []*plugin.Sym{
+			{[]string{"line1000"}, m.name, 0x1000, 0x1003},
+			{[]string{"line3000"}, m.name, 0x3000, 0x3004},
+		}, nil
+	}
+	return nil, fmt.Errorf("unimplemented")
+}
+
+// Close closes the file, releasing associated resources.
+func (*mockFile) Close() error {
+	return nil
+}

internal/driver/testdata/cppbench.svg

-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
- "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<!-- Generated by graphviz version 2.36.0 (20140111.2315)
- -->
-<!-- Title: cppbench_server_main Pages: 1 -->
-<svg width="555pt" height="210pt"
- viewBox="0.00 0.00 555.00 210.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 206)">
-<title>cppbench_server_main</title>
-<polygon fill="white" stroke="none" points="-4,4 -4,-206 551,-206 551,4 -4,4"/>
-<g id="clust1" class="cluster"><title>cluster_L</title>
-<polygon fill="none" stroke="black" points="8,-80 8,-194 402,-194 402,-80 8,-80"/>
-</g>
-<!-- File: cppbench_server_main -->
-<g id="node1" class="node"><title>File: cppbench_server_main</title>
-<polygon fill="#f8f8f8" stroke="black" points="394.25,-186 15.75,-186 15.75,-88 394.25,-88 394.25,-186"/>
-<text text-anchor="start" x="23.5" y="-169.2" font-family="Times,serif" font-size="16.00">File: cppbench_server_main</text>
-<text text-anchor="start" x="23.5" y="-151.2" font-family="Times,serif" font-size="16.00">Type: cpu</text>
-<text text-anchor="start" x="23.5" y="-133.2" font-family="Times,serif" font-size="16.00">0 of 7120000000ns total (0%)</text>
-<text text-anchor="start" x="23.5" y="-115.2" font-family="Times,serif" font-size="16.00">Dropped 56 nodes (cum &lt;= 35600000ns)</text>
-<text text-anchor="start" x="23.5" y="-97.2" font-family="Times,serif" font-size="16.00">Showing top 2 nodes out of 38 (cum &gt;= 7070000000ns)</text>
-</g>
-<!-- N1 -->
-<g id="node2" class="node"><title>N1</title>
-<g id="a_node2"><a xlink:title="start_thread (7120000000ns)">
-<polygon fill="#f8f8f8" stroke="black" points="513,-155 413,-155 413,-119 513,-119 513,-155"/>
-<text text-anchor="middle" x="463" y="-139.6" font-family="Times,serif" font-size="8.00">start_thread</text>
-<text text-anchor="middle" x="463" y="-130.6" font-family="Times,serif" font-size="8.00">0 of 7120000000ns(100%)</text>
-</a>
-</g>
-</g>
-<!-- N2 -->
-<g id="node3" class="node"><title>N2</title>
-<g id="a_node3"><a xlink:title="RunWorkerLoop (7070000000ns)">
-<polygon fill="#f8f8f8" stroke="black" points="515.5,-36 410.5,-36 410.5,-0 515.5,-0 515.5,-36"/>
-<text text-anchor="middle" x="463" y="-20.6" font-family="Times,serif" font-size="8.00">RunWorkerLoop</text>
-<text text-anchor="middle" x="463" y="-11.6" font-family="Times,serif" font-size="8.00">0 of 7070000000ns(99.30%)</text>
-</a>
-</g>
-</g>
-<!-- N1&#45;&gt;N2 -->
-<g id="edge1" class="edge"><title>N1&#45;&gt;N2</title>
-<g id="a_edge1"><a xlink:title="start_thread ... RunWorkerLoop (7070000000ns)">
-<path fill="none" stroke="black" stroke-width="5" stroke-dasharray="1,5" d="M463,-118.987C463,-99.9242 463,-68.7519 463,-46.2768"/>
-<polygon fill="black" stroke="black" stroke-width="5" points="467.375,-46.0333 463,-36.0333 458.625,-46.0334 467.375,-46.0333"/>
-</a>
-</g>
-<g id="a_edge1&#45;label"><a xlink:title="start_thread ... RunWorkerLoop (7070000000ns)">
-<text text-anchor="middle" x="505" y="-58.3" font-family="Times,serif" font-size="14.00"> 7070000000ns</text>
-</a>
-</g>
-</g>
-</g>
-</svg>

internal/driver/testdata/pprof.cpu.svg

-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
- "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<!-- Generated by graphviz version 2.36.0 (20140111.2315)
- -->
-<!-- Title: cppbench_server_main Pages: 1 -->
-<svg width="100%" height="100%" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-<script></script><g id="viewport" transform="scale(0.5,0.5) translate(0,0)"><g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 206)">
-<title>cppbench_server_main</title>
-<polygon fill="white" stroke="none" points="-4,4 -4,-206 551,-206 551,4 -4,4"/>
-<g id="clust1" class="cluster"><title>cluster_L</title>
-<polygon fill="none" stroke="black" points="8,-80 8,-194 402,-194 402,-80 8,-80"/>
-</g>
-<!-- File: cppbench_server_main -->
-<g id="node1" class="node"><title>File: cppbench_server_main</title>
-<polygon fill="#f8f8f8" stroke="black" points="394.25,-186 15.75,-186 15.75,-88 394.25,-88 394.25,-186"/>
-<text text-anchor="start" x="23.5" y="-169.2" font-family="Times,serif" font-size="16.00">File: cppbench_server_main</text>
-<text text-anchor="start" x="23.5" y="-151.2" font-family="Times,serif" font-size="16.00">Type: cpu</text>
-<text text-anchor="start" x="23.5" y="-133.2" font-family="Times,serif" font-size="16.00">0 of 7120000000ns total (0%)</text>
-<text text-anchor="start" x="23.5" y="-115.2" font-family="Times,serif" font-size="16.00">Dropped 56 nodes (cum &lt;= 35600000ns)</text>
-<text text-anchor="start" x="23.5" y="-97.2" font-family="Times,serif" font-size="16.00">Showing top 2 nodes out of 38 (cum &gt;= 7070000000ns)</text>
-</g>
-<!-- N1 -->
-<g id="node2" class="node"><title>N1</title>
-<g id="a_node2"><a xlink:title="start_thread (7120000000ns)">
-<polygon fill="#f8f8f8" stroke="black" points="513,-155 413,-155 413,-119 513,-119 513,-155"/>
-<text text-anchor="middle" x="463" y="-139.6" font-family="Times,serif" font-size="8.00">start_thread</text>
-<text text-anchor="middle" x="463" y="-130.6" font-family="Times,serif" font-size="8.00">0 of 7120000000ns(100%)</text>
-</a>
-</g>
-</g>
-<!-- N2 -->
-<g id="node3" class="node"><title>N2</title>
-<g id="a_node3"><a xlink:title="RunWorkerLoop (7070000000ns)">
-<polygon fill="#f8f8f8" stroke="black" points="515.5,-36 410.5,-36 410.5,-0 515.5,-0 515.5,-36"/>
-<text text-anchor="middle" x="463" y="-20.6" font-family="Times,serif" font-size="8.00">RunWorkerLoop</text>
-<text text-anchor="middle" x="463" y="-11.6" font-family="Times,serif" font-size="8.00">0 of 7070000000ns(99.30%)</text>
-</a>
-</g>
-</g>
-<!-- N1&#45;&gt;N2 -->
-<g id="edge1" class="edge"><title>N1&#45;&gt;N2</title>
-<g id="a_edge1"><a xlink:title="start_thread ... RunWorkerLoop (7070000000ns)">
-<path fill="none" stroke="black" stroke-width="5" stroke-dasharray="1,5" d="M463,-118.987C463,-99.9242 463,-68.7519 463,-46.2768"/>
-<polygon fill="black" stroke="black" stroke-width="5" points="467.375,-46.0333 463,-36.0333 458.625,-46.0334 467.375,-46.0333"/>
-</a>
-</g>
-<g id="a_edge1&#45;label"><a xlink:title="start_thread ... RunWorkerLoop (7070000000ns)">
-<text text-anchor="middle" x="505" y="-58.3" font-family="Times,serif" font-size="14.00"> 7070000000ns</text>
-</a>
-</g>
-</g>
-</g>
-</g></svg>

internal/driver/testdata/wrapper/addr2line

-#!/bin/bash
-# Copyright 2014 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# addr2line stub for testing of addr2liner.
-# Will recognize (and ignore) the -aiCfej options.
-#
-# Accepts addresses 1000 to 9000 and output multiple frames of the form:
-#   0x9000/fun9000/file9000:9000
-#   0x8000/fun8000/file8000:8000
-#   0x7000/fun7000/file7000:7000
-#   ...
-#   0x1000/fun1000/file1000:1000
-#
-# Returns ??/??/??:0 for all other inputs.
-
-while getopts aiCfe:j: opt; do
-  case "$opt" in
-    a|i|C|f|e|j) ;;
-    *)
-      echo "unrecognized option: $1" >&2
-      exit 1
-  esac
-done
-
-while read input
-do
-  address="$input"
-  
-  # remove 0x from input.
-  case "${address}" in
-    0x*)
-      address=$(printf '%x' "$address")
-      ;;
-    *)
-      address=$(printf '%x' "0x$address")
-  esac
-
-  printf '0x%x\n' "0x$address"
-  loop=1
-  while [ $loop -eq 1 ]
-  do
-    # prepare default output.
-    output2="fun${address}"
-    output3="file${address}:${address}"
-
-    # specialize output for selected cases.
-	  case "${address}" in
-      1000)
-        output2="_Z3fooid.clone2"
-        loop=0
-        ;;
-      2000)
-        output2="_ZNSaIiEC1Ev.clone18"
-        address=1000
-        ;;
-      3000)
-        output2="_ZNSt6vectorIS_IS_IiSaIiEESaIS1_EESaIS3_EEixEm"
-        address=2000
-        ;;
-      [4-9]000)
-        address=$(expr ${address} - 1000)
-        ;;
-      *)
-        output2='??'
-        output3='??:0'
-        loop=0
-    esac
-
-    echo "$output2"
-    echo "$output3"
-  done
-done
-exit 0

internal/driver/testdata/wrapper/dot

-#!/bin/bash
-# Copyright 2014 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-case "$1" in
-  "-Tsvg" )
-	  if ! grep -q 'Type: cpu.*Duration: 10s' ; then
-	    echo "Couldn't recognize dot input" >&2
-      exit 1
-    fi
-	  cat testdata/cppbench.svg
-    exit 0
-    ;;
-  *       )
-    echo "Unexpected argument $1" >&2
-    exit 1
-    ;;
-esac

internal/driver/testdata/wrapper/nm

-#!/bin/bash
-# Copyright 2014 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# nm stub for testing of listing.
-# Will recognize (and ignore) the -nC options.
-#
-# Outputs fixed nm output.
-
-while getopts nC opt; do
-  case "$opt" in
-    n) ;;
-    C) demangle=1;;
-    *)
-      echo "unrecognized option: $1" >&2
-      exit 1
-  esac
-done
-
-if [ $demangle ] 
-then
-  cat <<EOF
-0000000000001000 t lineA001
-0000000000001000 t lineA002
-0000000000001000 t line1000
-0000000000002000 t line200A
-0000000000002000 t line2000
-0000000000002000 t line200B
-0000000000003000 t line3000
-0000000000003000 t Dumb::operator()(char const*) const
-0000000000003000 t lineB00C
-0000000000003000 t line300D
-0000000000004000 t _the_end
-EOF
-  exit 0
-fi
-
-cat <<EOF
-0000000000001000 t lineA001
-0000000000001000 t lineA002
-0000000000001000 t line1000
-0000000000002000 t line200A
-0000000000002000 t line2000
-0000000000002000 t line200B
-0000000000003000 t line3000
-0000000000003000 t _ZNK4DumbclEPKc
-0000000000003000 t lineB00C
-0000000000003000 t line300D
-0000000000004000 t _the_end
-EOF
-exit 0

internal/driver/testdata/wrapper/objdump

-#!/bin/bash
-# Copyright 2014 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# objdump stub for testing of listing.
-# Will recognize (and ignore) the -nC options.
-#
-# Outputs fixed nm output.
-
-START=0
-STOP=0
-while [ $# -gt 1 ] ; do 
- case "$1" in 
-   --start-address=*) START=$(echo $1 | sed 's/.*=//') ;;
-   --stop-address=*) STOP=$(echo $1 | sed 's/.*=//') ;; 
-   --no-show-raw-insn|-d|-C|-n|-l) ;;
-   *) echo "Unrecognized option $1"
-     exit 1
- esac
- shift
-done
-
-case "$START$STOP" in 
-  "0x10000x1fff")
-  cat <<EOF
-  1000: instruction one
-  1001: instruction two
-  1002: instruction three
-  1003: instruction four
-EOF
-  ;;
-  "0x20000x2fff")
-  cat <<EOF
-  2000: instruction one
-  2001: instruction two
-EOF
-  ;;
-  "0x30000x3fff")
-  cat <<EOF
-  3000: instruction one
-  3001: instruction two
-  3002: instruction three
-  3003: instruction four
-  3004: instruction five
-EOF
-  ;;
-esac
-exit 0