Merge pull request #17 from rauls5382/master

Add source_path option to point pprof to source files

internal/driver/commands.go

 		" For memory profiles, use megabytes, kilobytes, bytes, etc.",
 		" auto will scale each value independently to the most natural unit.")},
 	"compact_labels": &variable{boolKind, "f", "", "Show minimal headers"},
+	"source_path":    &variable{stringKind, "", "", "Search path for source files"},
 
 	// Filtering options
 	"nodecount": &variable{intKind, "-1", "", helpText(

internal/driver/driver.go

 		SampleUnit:  sample.Unit,
 
 		OutputUnit: vars["unit"].value,
+
+		SourcePath: vars["source_path"].stringValue(),
 	}
 
 	if len(p.Mapping) > 0 && p.Mapping[0].File != "" {

internal/driver/interactive.go

 			if o.boolValue() == false {
 				continue
 			}
+		case n == "source_path":
+			continue
 		}
 		args = append(args, fmt.Sprintf("  %-25s : %s", n, v))
 	}

internal/report/report.go

 
 	OutputUnit string // Units for data formatting in report.
 
-	Symbol *regexp.Regexp // Symbols to include on disassembly report.
+	Symbol     *regexp.Regexp // Symbols to include on disassembly report.
+	SourcePath string         // Search path for source files.
 }
 
 // New builds a new report indexing the sample values interpreting the

internal/report/source.go

 	}
 	functions.Sort(graph.NameOrder)
 
+	sourcePath := o.SourcePath
+	if sourcePath == "" {
+		wd, err := os.Getwd()
+		if err != nil {
+			return fmt.Errorf("Could not stat current dir: %v", err)
+		}
+		sourcePath = wd
+	}
+
 	fmt.Fprintf(w, "Total: %s\n", rpt.formatValue(rpt.total))
 	for _, fn := range functions {
 		name := fn.Info.Name
 			fns := fileNodes[filename]
 			flatSum, cumSum := fns.Sum()
 
-			fnodes, path, err := getFunctionSource(name, filename, fns, 0, 0)
+			fnodes, path, err := getFunctionSource(name, filename, sourcePath, fns, 0, 0)
 			fmt.Fprintf(w, "ROUTINE ======================== %s in %s\n", name, path)
 			fmt.Fprintf(w, "%10s %10s (flat, cum) %s of Total\n",
 				rpt.formatValue(flatSum), rpt.formatValue(cumSum),
 		address = &hex
 	}
 
+	sourcePath := o.SourcePath
+	if sourcePath == "" {
+		wd, err := os.Getwd()
+		if err != nil {
+			return fmt.Errorf("Could not stat current dir: %v", err)
+		}
+		sourcePath = wd
+	}
+
 	// Extract interesting symbols from binary files in the profile and
 	// classify samples per symbol.
 	symbols := symbolsFromBinaries(rpt.prof, g, o.Symbol, address, obj)
 			asm := assemblyPerSourceLine(symbols, fns, filename, obj)
 			start, end := sourceCoordinates(asm)
 
-			fnodes, path, err := getFunctionSource(name, filename, fns, start, end)
+			fnodes, path, err := getFunctionSource(name, filename, sourcePath, fns, start, end)
 			if err != nil {
 				fnodes, path = getMissingFunctionSource(filename, asm, start, end)
 			}
 // getFunctionSource collects the sources of a function from a source
 // file and annotates it with the samples in fns. Returns the sources
 // as nodes, using the info.name field to hold the source code.
-func getFunctionSource(fun, file string, fns graph.Nodes, start, end int) (graph.Nodes, string, error) {
-	f, file, err := adjustSourcePath(file)
+func getFunctionSource(fun, file, sourcePath string, fns graph.Nodes, start, end int) (graph.Nodes, string, error) {
+	f, file, err := openSourceFile(file, sourcePath)
 	if err != nil {
 		return nil, file, err
 	}
 	return fnodes, filename
 }
 
-// adjustSourcePath adjusts the path for a source file by trimmming
-// known prefixes and searching for the file on all parents of the
-// current working dir.
-func adjustSourcePath(path string) (*os.File, string, error) {
+// openSourceFile opens a source file from a name encoded in a
+// profile. File names in a profile after often relative paths, so
+// search them in each of the paths in searchPath (or CWD by default),
+// and their parents.
+func openSourceFile(path, searchPath string) (*os.File, string, error) {
 	path = trimPath(path)
-	f, err := os.Open(path)
-	if err == nil {
-		return f, path, nil
+
+	if filepath.IsAbs(path) {
+		f, err := os.Open(path)
+		return f, path, err
 	}
 
-	if dir, wderr := os.Getwd(); wderr == nil {
+	// Scan each component of the path
+	for _, dir := range strings.Split(searchPath, ":") {
+		// Search up for every parent of each possible path.
 		for {
+			filename := filepath.Join(dir, path)
+			if f, err := os.Open(filename); err == nil {
+				return f, filename, nil
+			}
 			parent := filepath.Dir(dir)
 			if parent == dir {
 				break
 			}
-			if f, err := os.Open(filepath.Join(parent, path)); err == nil {
-				return f, filepath.Join(parent, path), nil
-			}
-
 			dir = parent
 		}
 	}
 
-	return nil, path, err
+	return nil, "", fmt.Errorf("Could not find file %s on path %s", path, searchPath)
 }
 
 // trimPath cleans up a path by removing prefixes that are commonly