first commit of OSS pprof

AUTHORS

+# This is the official list of pprof authors for copyright purposes.
+# This file is distinct from the CONTRIBUTORS files.
+# See the latter for an explanation.
+# Names should be added to this file as:
+# Name or Organization <email address>
+# The email address is not required for organizations.
+Google Inc.

COMPILE.sh

+#!/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.
+
+ROOT=${PWD}
+
+echo Building pprof at ${ROOT}
+GOPATH=${ROOT}:${ROOT}/third_party go build pprof 
+RETCODE=$?
+
+if [ ${RETCODE} -eq 0 ]
+then
+   echo Build was successful. pprof available at ${ROOT}/pprof
+else
+   echo Build failed.
+   exit 1
+fi
+

CONTRIBUTING

+Want to contribute? Great! First, read this page (including the small print at the end).
+
+### Before you contribute
+Before we can use your code, you must sign the
+[Google Individual Contributor License Agreement]
+(https://cla.developers.google.com/about/google-individual)
+(CLA), which you can do online. The CLA is necessary mainly because you own the
+copyright to your changes, even after your contribution becomes part of our
+codebase, so we need your permission to use and distribute your code. We also
+need to be sure of various other things—for instance that you'll tell us if you
+know that your code infringes on other people's patents. You don't have to sign
+the CLA until after you've submitted your code for review and a member has
+approved it, but you must do it before we can put your code into our codebase.
+Before you start working on a larger contribution, you should get in touch with
+us first through the issue tracker with your idea so that we can help out and
+possibly guide you. Coordinating up front makes it much easier to avoid
+frustration later on.
+
+### Code reviews
+All submissions, including submissions by project members, require review. We
+use Github pull requests for this purpose.
+
+### The small print
+Contributions made by corporations are covered by a different agreement than
+the one above, the
+[Software Grant and Corporate Contributor License Agreement]
+(https://cla.developers.google.com/about/google-corporate).

CONTRIBUTORS

+# People who have agreed to one of the CLAs and can contribute patches.
+# The AUTHORS file lists the copyright holders; this file
+# lists people.  For example, Google employees are listed here
+# but not in AUTHORS, because Google holds the copyright.
+#
+# https://developers.google.com/open-source/cla/individual
+# https://developers.google.com/open-source/cla/corporate
+#
+# Names should be added to this file as:
+#     Name <email address>
+Raul Silvera <rsilvera@google.com>
+Tipp Moseley <tipp@google.com>
+Hyoun Kyu Cho <netforce@google.com>
+

LICENSE

+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

README.md

+# Introduction
+
+pprof is a tool for visualization and analysis of profiling data.
+
+pprof reads a collection of profiling samples in profile.proto format and
+generates reports to visualize and help analyze the data. It can generate both
+text and graphical reports (through the use of the dot visualization package).
+
+profile.proto is a protocol buffer that describes a set of callstacks
+and symbolization information. A common usage is to represent a set of
+sampled callstacks from statistical profiling. The format is
+described on the src/proto/profile.proto file. For details on protocol
+buffers, see https://developers.google.com/protocol-buffers
+
+Profiles can be read from a local file, or over http. Multiple
+profiles of the same type can be aggregated or compared.
+
+If the profile samples contain machine addresses, pprof can symbolize
+them through the use of the native binutils tools (addr2line and nm).
+
+**This is not an official Google product.**
+
+# Building pprof
+
+Prerequisites:
+
+- Go development kit: https://golang.org/dl/
+  Known to work with Go 1.5
+- Graphviz: http://www.graphviz.org/
+  Optional, used to generate graphic visualizations of profiles
+
+To build it, run the COMPILE.sh script. The TEST.sh script runs unit tests.
+
+# Basic usage
+
+pprof can read a profile from a file or directly from a server via http.
+Specify the profile input(s) in the command line, and use options to
+indicate how to format the report.
+
+## Generate a text report of the profile, sorted by hotness:
+
+```
+% pprof -top [main_binary] profile.pb.gz
+Where
+    main_binary:  Local path to the main program binary, to enable symbolization
+    profile.pb.gz: Local path to the profile in a compressed protobuf, or
+                   URL to the http service that serves a profile.
+```
+
+## Generate a graph in an SVG file, and open it with a web browser:
+
+```
+pprof -web [main_binary] profile.pb.gz
+```
+
+## Run pprof on interactive mode:
+
+If no output formatting option is specified, pprof runs on interactive mode,
+where reads the profile and accepts interactive commands for visualization and
+refinement of the profile.
+
+```
+pprof [main_binary] profile.pb.gz
+
+This will open a simple shell that takes pprof commands to generate reports.
+Type 'help' for available commands/options.
+```
+
+## Further documentation
+
+See doc/pprof.md for more detailed end-user documentation.
+
+See doc/developer/pprof.dev.md for developer documentation.
+
+See doc/developer/profile.proto.md for a description of the profile.proto format.

TEST.sh

+#!/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.
+
+ROOT=${PWD}
+INTERNAL="internal/binutils internal/driver internal/elfexec internal/graph internal/report internal/symbolizer internal/symbolz"
+PACKAGES="profile ${INTERNAL}"
+
+echo Testing pprof packages at ${ROOT}
+GOPATH=${ROOT}:${ROOT}/third_party go test $PACKAGES
+RETCODE=$?
+
+if [ ${RETCODE} -eq 0 ]
+then
+   echo Tests were successful.
+else
+   echo Tests failed.
+fi

doc/developer/pprof.dev.md

+This is pprof's developer documentation. It discusses how to maintain and extend
+pprof. It has yet to be written.
+
+# How is pprof code structured?
+
+Internal vs external packages.
+
+# External interface
+
+## Plugins
+
+## Legacy formats
+
+#  Overview of internal packages

doc/developer/profile.proto.md

+This is a description of the profile.proto format.
+
+# Overview
+
+Profile.proto is a data representation for profile data. It is independent of
+the type of data being collected and the sampling process used to collect that
+data. On disk, it is represented as a gzip-compressed protocol buffer, described
+at src/proto/profile.proto
+
+A profile in this context refers to a collection of samples, each one
+representing measurements performed at a certain point in the life of a job. A
+sample associates a set of measurement values with a list of locations, commonly
+representing the program call stack when the sample was taken.
+
+Tools such as pprof analyze these samples and display this information in
+multiple forms, such as identifying hottest locations, building graphical call
+graphs or trees, etc.
+
+# General structure of a profile
+
+A profile is represented on a Profile message, which contain the following
+fields:
+
+* *sample*: A profile sample, with the values measured and the associated call
+  stack as a list of location ids. Samples with identical call stacks can be
+  merged by adding their respective values, element by element.
+* *location*: A unique place in the program, commonly mapped to a single
+  instruction address. It has a unique nonzero id, to be referenced from the
+  samples. It contains source information in the form of lines, and a mapping id
+  that points to a binary.
+* *function*: A program function as defined in the program source. It has a
+  unique nonzero id, referenced from the location lines. It contains a
+  human-readable name for the function (eg a C++ demangled name), a system name
+  (eg a C++ mangled name), the name of the corresponding source file, and other
+  function attributes.
+* *mapping*: A binary that is part of the program during the profile
+  collection. It has a unique nonzero id, referenced from the locations. It
+  includes details on how the binary was mapped during program execution. By
+  convention the main program binary is the first mapping, followed by any
+  shared libraries.
+* *string_table*: All strings in the profile are represented as indices into
+  this repeating field. The first string is empty, so index == 0 always
+  represents the empty string.
+
+# Measurement values
+
+Measurement values are represented as 64-bit integers. The profile contains an
+explicit description of each value represented, using a ValueType message, with
+two fields:
+
+* *Type*: A human-readable description of the type semantics. For example “cpu”
+  to represent CPU time, “wall” or “time” for wallclock time, or “memory” for
+  bytes allocated.
+* *Unit*: A human-readable name of the unit represented by the 64-bit integer
+  values. For example, it could be “nanoseconds” or “milliseconds” for a time
+  value, or “bytes” or “megabytes” for a memory size. If this is just
+  representing a number of events, the recommended unit name is “count”.
+
+A profile can represent multiple measurements per sample, but all samples must
+have the same number and type of measurements. The actual values are stored in
+the Sample.value fields, each one described by the corresponding
+Profile.sample_type field.
+
+Some profiles have a uniform period that describe the granularity of the data
+collection. For example, a CPU profile may have a period of 100ms, or a memory
+allocation profile may have a period of 512kb. Profiles can optionally describe
+such a value on the Profile.period and Profile.period_type fields. The profile
+period is meant for human consumption and does not affect the interpretation of
+the profiling data.
+
+By convention, the first value on all profiles is the number of samples
+collected at this call stack, with unit “count”. Because the profile does not
+describe the sampling process beyond the optional period, it must include
+unsampled values for all measurements. For example, a CPU profile could have
+value[0] == samples, and value[1] == time in milliseconds.
+
+## Locations, functions and mappings
+
+Each sample lists the id of each location where the sample was collected, in
+bottom-up order. Each location has an explicit unique nonzero integer id,
+independent of its position in the profile, and holds additional information to
+identify the corresponding source.
+
+The profile source is expected to perform any adjustment required to the
+locations in order to point to the calls in the stack. For example, if the
+profile source extracts the call stack by walking back over the program stack,
+it must adjust the instruction addresses to point to the actual call
+instruction, instead of the instruction that each call will return to.
+
+Sources usually generate profiles that fall into these two categories:
+
+* *Unsymbolized profiles*: These only contain instruction addresses, and are to
+  be symbolized by a separate tool. It is critical for each location to point to
+  a valid mapping, which will provide the information required for
+  symbolization. These are used for profiles of compiled languages, such as C++
+  and Go.
+
+* *Symbolized profiles*: These contain all the symbol information available for
+  the profile. Mappings and instruction addresses are optional for symbolized
+  locations. These are used for profiles of interpreted or jitted languages,
+  such as Java or Python.  Also, the profile format allows the generation of
+  mixed profiles, with symbolized and unsymbolized locations.
+
+The symbol information is represented in the repeating lines field of the
+Location message. A location has multiple lines if it reflects multiple program
+sources, for example if representing inlined call stacks. Lines reference
+functions by their unique nonzero id, and the source line number within the
+source file listed by the function. A function contains the source attributes
+for a function, including its name, source file, etc. Functions include both a
+user and a system form of the name, for example to include C++ demangled and
+mangled names. For profiles where only a single name exists, both should be set
+to the same string.
+
+Mappings are also referenced from locations by their unique nonzero id, and
+include all information needed to symbolize addresses within the mapping. It
+includes similar information to the Linux /proc/self/maps file. Locations
+associated to a mapping should have addresses that land between the mapping
+start and limit. Also, if available, mappings should include a build id to
+uniquely identify the version of the binary being used.
+
+## Labels
+
+Samples optionally contain labels, which are annotations to discriminate samples
+with identical locations. For example, a label can be used on a malloc profile
+to indicate allocation size, so two samples on the same call stack with sizes
+2MB and 4MB do not get merged into a single sample with two allocations and a
+size of 6MB.
+
+Labels can be string-based or numeric. They are represented by the Label
+message, with a key identifying the label and either a string or numeric
+value. For numeric labels, by convention the key represents the measurement unit
+of the numeric value. So for the previous example, the samples would have labels
+{“bytes”, 2097152} and {“bytes”, 4194304}.
+
+## Keep and drop expressions
+
+Some profile sources may have knowledge of locations that are uninteresting or
+irrelevant. However, if symbolization is needed in order to identify these
+locations, the profile source may not be able to remove them when the profile is
+generated. The profile format provides a mechanism to identify these frames by
+name, through regular expressions.
+
+These expressions must match the function name in its entirety. Frames that
+match Profile.drop\_frames will be dropped from the profile, along with any
+frames below it. Frames that match Profile.keep\_frames will be kept, even if
+they match drop\_frames.
+

doc/pprof.md

+# pprof
+
+pprof is a tool for visualization and analysis of profiling data.
+
+pprof reads a collection of profiling samples in profile.proto format and
+generates reports to visualize and help analyze the data. It can generate both
+text and graphical reports (through the use of the dot visualization package).
+
+profile.proto is a protocol buffer that describes a set of callstacks
+and symbolization information. A common usage is to represent a set of
+sampled callstacks from statistical profiling. The format is
+described on the src/proto/profile.proto file. For details on protocol
+buffers, see https://developers.google.com/protocol-buffers
+
+Profiles can be read from a local file, or over http. Multiple
+profiles of the same type can be aggregated or compared.
+
+If the profile samples contain machine addresses, pprof can symbolize
+them through the use of the native binutils tools (addr2line and nm).
+
+# pprof profiles
+
+pprof operates on data in the profile.proto format. Each profile is a collection
+of samples, where each sample is associated to a point in a location hierarchy,
+one or more numeric values, and a set of labels. Often these profiles represents
+data collected through statistical sampling of a program, so each sample
+describes a program call stack and a number or weight of samples collected at a
+location. pprof is agnostic to the profile semantics, so other uses are
+possible. The interpretation of the reports generated by pprof depends on the
+semantics defined by the source of the profile.
+
+# General usage
+
+The objective of pprof is to generate a report for a profile. The report is
+generated from a location hierarchy, which is reconstructed from the profile
+samples. Each location contains two values: *flat* is the value of the location
+itself, while *cum* is the value of the location plus all its
+descendants. Samples that include a location multiple times (eg for recursive
+functions) are counted only once per location.
+
+The basic usage of pprof is
+
+    pprof <format> [options] source
+
+Where *format* selects the nature of the report, and *options* configure the
+contents of the report. Each option has a value, which can be boolean, numeric,
+or strings. While only one format can be specified, most options can be selected
+independently of each other.
+
+Some common pprof options are:
+
+* **-flat [default]:** Sort entries based on their flat weight, on text reports.
+* **-cum:** Sort entries based on cumulative weight, on text reports.
+* **-functions [default]:** Accumulate samples at the function level; profile
+  locations that describe the same function will be merged into a report entry.
+* **-lines:** Accumulate samples at the source line level; profile locations that
+  describe the same function will be merged into a report entry.
+* **-addresses:** Accumulate samples at the instruction address; profile locations
+  that describe the same function address will be merged into a report entry.
+* **-nodecount= _int_:** Maximum number of entries in the report. pprof will only print
+  this many entries and will use heuristics to select which entries to trim.
+* **-focus= _regex_:** Only include samples that include a report entry matching
+  *regex*.
+* **-ignore= _regex_:** Do not include samples that include a report entry matching
+  *regex*.
+* **-show= _regex_:** Only show entries that match *regex*.
+* **-hide= _regex_:** Do not show entries that match *regex*.
+
+Each sample in a profile may include multiple values, representing different
+entities associated to the sample. pprof reports include a single sample value,
+which by convention is the last one specified in the report. The `sample_index=`
+option selects which value to use, and can be set to a number (from 0 to the
+number of values - 1) or the name of the sample value.
+
+Sample values are numeric values associated to a unit. If pprof can recognize
+these units, it will attempt to scale the values to a suitable unit for
+visualization. The `unite=` option will force the use of a specific unit. For
+example, `sample_index=sec` will force any time values to be reported in
+seconds. pprof recognizes most common time and memory size units.
+
+## Text reports
+
+pprof text reports show the location hierarchy in text format.
+
+* **-text:** Prints the location entries, one per line, including the flat and cum
+  values.
+* **-tree:** Prints each location entry with its predecessors and successors. 
+* **-peek= _regex_:** Print the location entry with all its predecessors and
+  successors, without trimming any entries.
+* **-traces:** Prints each sample with a location per line.
+
+## Graphical reports
+
+pprof can generate graphical reports on the DOT format, and convert them to
+multiple formats using the graphviz package.
+
+These reports represent the location hierarchy as a graph, with a report entry
+represented as a node. Solid edges represent a direct connection between
+entries, while dotted edges represent a connection where some intermediate nodes
+have been removed. Nodes are removed using heuristics to limit the size of
+the graph, controlled by the *nodecount* option.
+
+The size of each node represents the flat weight of the node, and the width of
+each edge represents the cumulative weight of all samples going through
+it. Nodes are colored according to their cumulative weight, highlighting the
+paths with the highest cum weight.
+
+* **-dot:** Generates a report in .dot format. All other formats are generated from
+  this one.
+* **-svg:** Generates a report in SVG format.
+* **-web:** Generates a report in SVG format on a temp file, and starts a web
+  browser to view it.
+* **-png, -jpg, -gif, -pdf:** Generates a report in these formats,
+
+## Annotated code
+
+pprof can also generate reports of annotated source with samples associated to
+them. For these, the source or binaries must be locally available, and the
+profile must contain data with the appropriate level of detail.
+
+pprof will look for source files on its current working directory and all its
+ancestors. pprof will look for binaries on the directories specified in the
+`$PPROF_BINARY_PATH` environment variable, by default `$HOME/pprof/binaries`. It
+will look binaries up by name, and if the profile includes linker build ids, it
+will also search for them in a directory named as the build id.
+
+pprof uses the binutils tools to examine and disassemble the binaries. By
+default it will search for those tools in the current path, but it can also
+search for them in a directory pointed to by the environment variable
+`$PPROF_TOOLS`.
+
+* **-disasm= _regex_:** Generates an annotated source listing for functions matching
+  regex, with flat/cum weights for each source line.
+* **-list= _regex_:** Generates an annotated disassembly listing for functions
+  matching *regex*.
+* **-weblist= _regex_:** Generates a source/assembly combined annotated listing for
+  functions matching *regex*, and starts a web browser to display it.
+
+# Fetching profiles
+
+pprof can read profiles from a file or directly from a URL over http. Its native
+format is a gzipped profile.proto file, but it can also accept some legacy
+formats generated by [gperftools](https://github.com/gperftools/gperftools).
+
+When fetching from a URL handler, pprof accepts options to indicate how much to
+wait for the profile.
+
+* **-seconds= _int_:** Makes pprof request for a profile with the specified duration
+  in seconds. Only makes sense for profiles based on elapsed time, such as CPU
+  profiles.
+* **-timeout= _int_:** Makes pprof wait for the specified timeout when retrieving a
+  profile over http. If not specified, pprof will use heuristics to determine a
+  reasonable timeout.
+
+If multiple profiles are specified, pprof will fetch them all and merge
+them. This is useful to combine profiles from multiple processes of a
+distributed job. The profiles may be from different programs but must be
+compatible (for example, CPU profiles cannot be combined with heap profiles).
+
+pprof can subtract a profile from another in order to compare them. For that,
+use the **-base= _profile_** option, where *profile* is the filename or URL for the
+profile to be subtracted. This may result on some report entries having negative
+values.
+
+## Symbolization
+
+pprof can add symbol information to a profile that was collected only with
+address information. This is useful for profiles for compiled languages, where
+it may not be easy or even possible for the profile source to include function
+names or source coordinates.
+
+pprof can extract the symbol information locally by examining the binaries using
+the binutils tools, or it can ask running jobs that provide a symbolization
+interface.
+
+pprof will attempt symbolizing profiles by default, and its `-symbolize` option
+provides some control over symbolization:
+
+* **-symbolize=none:** Disables any symbolization from pprof.
+
+* **-symbolize=local:** Only attempts symbolizing the profile from local
+  binaries using the binutils tools.
+
+* **-symbolize=remote:** Only attempts to symbolize running jobs by contacting
+  their symbolization handler.
+
+For local symbolization, pprof will look for the binaries on the paths specified
+by the profile, and then it will search for them on the path specified by the
+environment variable `$PPROF_BINARY_PATH`. Also, the name of the main binary can
+be passed directly to pprof as its first parameter, to override the name or
+location of the main binary of the profile, like this:
+
+    pprof /path/to/binary profile.pb.gz
+
+By default pprof will attempt to demangle and simplify C++ names, to provide
+readable names for C++ symbols. It will aggressively discard template and
+function parameters. This can be controlled with the `-symbolize=demangle`
+option. Note that for remote symbolization mangled names may not be provided by
+the symbolization handler.
+
+* **--symbolize=demangle=none:** Do not perform any demangling. Show mangled
+  names if available.
+
+* **-symbolize=demangle=full:** Demangle, but do not perform any
+  simplification. Show full demangled names if available.
+
+* **-symbolize=demangle=templates:** Demangle, and trim function parameters, but
+  not template parameters.
+

src/driver/driver.go

+// 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.
+
+// Package driver provides an external entry point to the pprof driver.
+package driver
+
+import (
+	internaldriver "internal/driver"
+	"internal/plugin"
+	"io"
+	"regexp"
+	"time"
+
+	"profile"
+)
+
+// PProf acquires a profile, and symbolizes it using a profile
+// manager. Then it generates a report formatted according to the
+// options selected through the flags package.
+func PProf(o *Options) error {
+	return internaldriver.PProf(o.InternalOptions())
+}
+
+func (o *Options) InternalOptions() *plugin.Options {
+	var obj plugin.ObjTool
+	if o.Obj != nil {
+		obj = &internalObjTool{o.Obj}
+	}
+	var sym plugin.Symbolizer
+	if o.Sym != nil {
+		sym = &internalSymbolizer{o.Sym}
+	}
+	return &plugin.Options{
+		o.Writer,
+		o.Flagset,
+		o.Fetch,
+		sym,
+		obj,
+		o.UI,
+	}
+}
+
+// Options groups all the optional plugins into pprof.
+type Options struct {
+	Writer  Writer
+	Flagset FlagSet
+	Fetch   Fetcher
+	Sym     Symbolizer
+	Obj     ObjTool
+	UI      UI
+}
+
+// Writer provides a mechanism to write data under a certain name,
+// typically a filename.
+type Writer interface {
+	Open(name string) (io.WriteCloser, error)
+}
+
+// A FlagSet creates and parses command-line flags.
+// It is similar to the standard flag.FlagSet.
+type FlagSet interface {
+	// Bool, Int, Float64, and String define new flags,
+	// like the functions of the same name in package flag.
+	Bool(name string, def bool, usage string) *bool
+	Int(name string, def int, usage string) *int
+	Float64(name string, def float64, usage string) *float64
+	String(name string, def string, usage string) *string
+
+	// BoolVar, IntVar, Float64Var, and StringVar define new flags referencing
+	// a given pointer, like the functions of the same name in package flag.
+	BoolVar(pointer *bool, name string, def bool, usage string)
+	IntVar(pointer *int, name string, def int, usage string)
+	Float64Var(pointer *float64, name string, def float64, usage string)
+	StringVar(pointer *string, name string, def string, usage string)
+
+	// StringList is similar to String but allows multiple values for a
+	// single flag
+	StringList(name string, def string, usage string) *[]*string
+
+	// ExtraUsage returns any additional text that should be
+	// printed after the standard usage message.
+	// The typical use of ExtraUsage is to show any custom flags
+	// defined by the specific pprof plugins being used.
+	ExtraUsage() string
+
+	// Parse initializes the flags with their values for this run
+	// and returns the non-flag command line arguments.
+	// If an unknown flag is encountered or there are no arguments,
+	// Parse should call usage and return nil.
+	Parse(usage func()) []string
+}
+
+// A Fetcher reads and returns the profile named by src, using
+// the specified duration and timeout. It returns the fetched
+// profile and a string indicating a URL from where the profile
+// was fetched, which may be different than src.
+type Fetcher interface {
+	Fetch(src string, duration, timeout time.Duration) (*profile.Profile, string, error)
+}
+
+// A Symbolizer introduces symbol information into a profile.
+type Symbolizer interface {
+	Symbolize(mode string, srcs MappingSources, prof *profile.Profile) error
+}
+
+// MappingSources map each profile.Mapping to the source of the profile.
+// The key is either Mapping.File or Mapping.BuildId.
+type MappingSources map[string][]struct {
+	Source string // URL of the source the mapping was collected from
+	Start  uint64 // delta applied to addresses from this source (to represent Merge adjustments)
+}
+
+// An ObjTool inspects shared libraries and executable files.
+type ObjTool interface {
+	// Open opens the named object file.  If the object is a shared
+	// library, start/limit/offset are the addresses where it is mapped
+	// into memory in the address space being inspected.
+	Open(file string, start, limit, offset uint64) (ObjFile, error)
+
+	// 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)
+}
+
+// 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
+}
+
+// An ObjFile is a single object file: a shared library or executable.
+type ObjFile interface {
+	// Name returns the underlying file name, if available.
+	Name() string
+
+	// Base returns the base address to use when looking up symbols in the file.
+	Base() uint64
+
+	// BuildID returns the GNU build ID of the file, or an empty string.
+	BuildID() string
+
+	// 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.
+	SourceLine(addr uint64) ([]Frame, error)
+
+	// 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.
+	Symbols(r *regexp.Regexp, addr uint64) ([]*Sym, error)
+
+	// Close closes the file, releasing associated resources.
+	Close() error
+}
+
+// A Frame describes a single line in a source file.
+type Frame struct {
+	Func string // name of function
+	File string // source file name
+	Line int    // line in file
+}
+
+// A Sym describes a single symbol in an object file.
+type Sym struct {
+	Name  []string // names of symbol (many if symbol was dedup'ed)
+	File  string   // object file containing symbol
+	Start uint64   // start virtual address
+	End   uint64   // virtual address of last byte in sym (Start+size-1)
+}
+
+// A UI manages user interactions.
+type UI interface {
+	// Read returns a line of text (a command) read from the user.
+	// prompt is printed before reading the command.
+	ReadLine(prompt string) (string, error)
+
+	// Print shows a message to the user.
+	// It formats the text as fmt.Print would and adds a final \n if not already present.
+	// For line-based UI, Print writes to standard error.
+	// (Standard output is reserved for report data.)
+	Print(...interface{})
+
+	// PrintErr shows an error message to the user.
+	// It formats the text as fmt.Print would and adds a final \n if not already present.
+	// For line-based UI, PrintErr writes to standard error.
+	PrintErr(...interface{})
+
+	// IsTerminal returns whether the UI is known to be tied to an
+	// interactive terminal (as opposed to being redirected to a file).
+	IsTerminal() bool
+
+	// SetAutoComplete instructs the UI to call complete(cmd) to obtain
+	// the auto-completion of cmd, if the UI supports auto-completion at all.
+	SetAutoComplete(complete func(string) string)
+}
+
+// internalObjTool is a wrapper to map from the pprof external
+// interface to the internal interface.
+type internalObjTool struct {
+	ObjTool
+}
+
+func (o *internalObjTool) Open(file string, start, limit, offset uint64) (plugin.ObjFile, error) {
+	f, err := o.ObjTool.Open(file, start, limit, offset)
+	if err != nil {
+		return nil, err
+	}
+	return &internalObjFile{f}, err
+}
+
+type internalObjFile struct {
+	ObjFile
+}
+
+func (f *internalObjFile) SourceLine(frame uint64) ([]plugin.Frame, error) {
+	frames, err := f.ObjFile.SourceLine(frame)
+	if err != nil {
+		return nil, err
+	}
+	var pluginFrames []plugin.Frame
+	for _, f := range frames {
+		pluginFrames = append(pluginFrames, plugin.Frame(f))
+	}
+	return pluginFrames, nil
+}
+
+func (f *internalObjFile) Symbols(r *regexp.Regexp, addr uint64) ([]*plugin.Sym, error) {
+	syms, err := f.ObjFile.Symbols(r, addr)
+	if err != nil {
+		return nil, err
+	}
+	var pluginSyms []*plugin.Sym
+	for _, s := range syms {
+		ps := plugin.Sym(*s)
+		pluginSyms = append(pluginSyms, &ps)
+	}
+	return pluginSyms, nil
+}
+
+func (o *internalObjTool) Disasm(file string, start, end uint64) ([]plugin.Inst, error) {
+	insts, err := o.ObjTool.Disasm(file, start, end)
+	if err != nil {
+		return nil, err
+	}
+	var pluginInst []plugin.Inst
+	for _, inst := range insts {
+		pluginInst = append(pluginInst, plugin.Inst(inst))
+	}
+	return pluginInst, nil
+}
+
+// internalSymbolizer is a wrapper to map from the pprof external
+// interface to the internal interface.
+type internalSymbolizer struct {
+	Symbolizer
+}
+
+func (s *internalSymbolizer) Symbolize(mode string, srcs plugin.MappingSources, prof *profile.Profile) error {
+	isrcs := plugin.MappingSources{}
+	for m, s := range srcs {
+		isrcs[m] = s
+	}
+	return s.Symbolize(mode, isrcs, prof)
+}

src/internal/binutils/addr2liner.go

+// 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.
+
+package binutils
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"internal/plugin"
+)
+
+const (
+	defaultAddr2line = "addr2line"
+
+	// addr2line may produce multiple lines of output. We
+	// use this sentinel to identify the end of the output.
+	sentinel = ^uint64(0)
+)
+
+// 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
+
+	base uint64
+}
+
+// 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
+// program under consideration.
+func newAddr2Liner(cmd, file string, base uint64) (*addr2Liner, error) {
+	if cmd == "" {
+		cmd = defaultAddr2line
+	}
+
+	a := &addr2Liner{
+		filename: file,
+		base:     base,
+		cmd:      exec.Command(cmd, "-aif", "-e", file),
+	}
+
+	var err error
+	if a.in, err = a.cmd.StdinPipe(); err != nil {
+		return nil, err
+	}
+
+	outPipe, err := a.cmd.StdoutPipe()
+	if err != nil {
+		return nil, err
+	}
+
+	a.out = bufio.NewReader(outPipe)
+	if err := a.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()
+}
+
+func (d *addr2Liner) readString() (s string) {
+	if d.err != nil {
+		return ""
+	}
+	if s, d.err = d.out.ReadString('\n'); d.err != nil {
+		return ""
+	}
+	return strings.TrimSpace(s)
+}
+
+// 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()
+
+	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
+		// addr2line
+		d.readString()
+		d.readString()
+		return plugin.Frame{}, true
+	}
+
+	fileline := d.readString()
+	if d.err != nil {
+		return plugin.Frame{}, true
+	}
+
+	linenumber := 0
+
+	if funcname == "??" {
+		funcname = ""
+	}
+
+	if fileline == "??:0" {
+		fileline = ""
+	} else {
+		if i := strings.LastIndex(fileline, ":"); i >= 0 {
+			// Remove discriminator, if present
+			if disc := strings.Index(fileline, " (discriminator"); disc > 0 {
+				fileline = fileline[:disc]
+			}
+			// If we cannot parse a number after the last ":", keep it as
+			// part of the filename.
+			if line, err := strconv.Atoi(fileline[i+1:]); err == nil {
+				linenumber = line
+				fileline = fileline[:i]
+			}
+		}
+	}
+
+	return plugin.Frame{funcname, fileline, linenumber}, false
+}
+
+// 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 _, d.err = fmt.Fprintf(d.in, "%x\n", sentinel); d.err != nil {
+		return nil, d.err
+	}
+
+	resp := d.readString()
+	if d.err != nil {
+		return nil, d.err
+	}
+
+	if !strings.HasPrefix(resp, "0x") {
+		d.err = fmt.Errorf("unexpected addr2line output: %s", resp)
+		return nil, d.err
+	}
+
+	var stack []plugin.Frame
+	for {
+		frame, end := d.readFrame()
+		if end {
+			break
+		}
+
+		if frame != (plugin.Frame{}) {
+			stack = append(stack, frame)
+		}
+	}
+	return stack, d.err
+}

src/internal/binutils/addr2liner_nm.go

+// 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.
+
+package binutils
+
+import (
+	"bufio"
+	"bytes"
+	"io"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"internal/plugin"
+)
+
+const (
+	defaultNM = "nm"
+)
+
+// addr2LinerNM is a connection to an nm command for obtaining address
+// information from a binary.
+type addr2LinerNM struct {
+	m []symbolInfo // Sorted list of addresses from binary.
+}
+
+type symbolInfo struct {
+	address uint64
+	name    string
+}
+
+//  newAddr2LinerNM starts the given nm 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 program under
+// consideration.
+func newAddr2LinerNM(cmd, file string, base uint64) (*addr2LinerNM, error) {
+	if cmd == "" {
+		cmd = defaultNM
+	}
+
+	a := &addr2LinerNM{
+		m: []symbolInfo{},
+	}
+
+	var b bytes.Buffer
+	c := exec.Command(cmd, "-n", file)
+	c.Stdout = &b
+
+	if err := c.Run(); err != nil {
+		return nil, err
+	}
+
+	// Parse addr2line output and populate symbol map.
+	// Skip lines we fail to parse.
+	buf := bufio.NewReader(&b)
+	for {
+		line, err := buf.ReadString('\n')
+		if line == "" && err != nil {
+			if err == io.EOF {
+				break
+			}
+			return nil, err
+		}
+		fields := strings.SplitN(line, " ", 3)
+		if len(fields) != 3 {
+			continue
+		}
+		address, err := strconv.ParseUint(fields[0], 16, 64)
+		if err != nil {
+			continue
+		}
+		a.m = append(a.m, symbolInfo{
+			address: address + base,
+			name:    fields[2],
+		})
+	}
+
+	return a, nil
+}
+
+// addrInfo returns the stack frame information for a specific program
+// address. It returns nil if the address could not be identified.
+func (a *addr2LinerNM) addrInfo(addr uint64) ([]plugin.Frame, error) {
+	if len(a.m) == 0 || addr < a.m[0].address || addr > a.m[len(a.m)-1].address {
+		return nil, nil
+	}
+
+	// Binary search. Search until low, high are separated by 1.
+	low, high := 0, len(a.m)
+	for low+1 < high {
+		mid := (low + high) / 2
+		v := a.m[mid].address
+		if addr == v {
+			low = mid
+			break
+		} else if addr > v {
+			low = mid
+		} else {
+			high = mid
+		}
+	}
+
+	// Address is between a.m[low] and a.m[high].
+	// Pick low, as it represents [low, high).
+	f := []plugin.Frame{
+		{
+			Func: a.m[low].name,
+		},
+	}
+	return f, nil
+}

src/internal/binutils/binutils.go

+// 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.
+
+// Package binutils provides access to the GNU binutils.
+package binutils
+
+import (
+	"debug/elf"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"internal/elfexec"
+	"internal/plugin"
+)
+
+// A Binutils implements plugin.ObjTool by invoking the GNU binutils.
+// SetConfig must be called before any of the other methods.
+type Binutils struct {
+	// Commands to invoke.
+	addr2line string
+	nm        string
+	objdump   string
+
+	// if fast, perform symbolization using nm (symbol names only),
+	// instead of file-line detail from the slower addr2line.
+	fast bool
+}
+
+// SetFastSymbolization sets a toggle that makes binutils use fast
+// symbolization (using nm), which is much faster than addr2line but
+// provides only symbol name information (no file/line).
+func (b *Binutils) SetFastSymbolization(fast bool) {
+	b.fast = fast
+}
+
+// SetTools processes the contents of the tools option. It
+// expects a set of entries separated by commas; each entry is a pair
+// of the form t:path, where cmd will be used to look only for the
+// tool named t. If t is not specified, the path is searched for all
+// tools.
+func (b *Binutils) SetTools(config string) {
+	// paths collect paths per tool; Key "" contains the default.
+	paths := make(map[string][]string)
+	for _, t := range strings.Split(config, ",") {
+		name, path := "", t
+		if ct := strings.SplitN(t, ":", 2); len(ct) == 2 {
+			name, path = ct[0], ct[1]
+		}
+		paths[name] = append(paths[name], path)
+	}
+
+	defaultPath := paths[""]
+	b.addr2line = findExe("addr2line", append(paths["addr2line"], defaultPath...))
+	b.nm = findExe("nm", append(paths["nm"], defaultPath...))
+	b.objdump = findExe("objdump", append(paths["objdump"], defaultPath...))
+}
+
+// findExe looks for an executable command on a set of paths.
+// If it cannot find it, returns cmd.
+func findExe(cmd string, paths []string) string {
+	for _, p := range paths {
+		cp := filepath.Join(p, cmd)
+		if c, err := exec.LookPath(cp); err == nil {
+			return c
+		}
+	}
+	return cmd
+}
+
+// Disasm returns the assembly instructions for the specified address range
+// of a binary.
+func (b *Binutils) Disasm(file string, start, end uint64) ([]plugin.Inst, error) {
+	if b.addr2line == "" {
+		// Update the command invocations if not initialized.
+		b.SetTools("")
+	}
+	return disassemble(b.objdump, file, start, end)
+}
+
+// Open satisfies the plugin.ObjTool interface.
+func (b *Binutils) Open(name string, start, limit, offset uint64) (plugin.ObjFile, error) {
+	if b.addr2line == "" {
+		// Update the command invocations if not initialized.
+		b.SetTools("")
+	}
+
+	// Make sure file is a supported executable.
+	// The pprof driver uses Open to sniff the difference
+	// between an executable and a profile.
+	// For now, only ELF is supported.
+	// Could read the first few bytes of the file and
+	// use a table of prefixes if we need to support other
+	// systems at some point.
+
+	f, err := os.Open(name)
+	if err != nil {
+		// For testing, do not require file name to exist.
+		if strings.Contains(b.addr2line, "testdata/") {
+			return &fileAddr2Line{file: file{b: b, name: name}}, nil
+		}
+
+		return nil, err
+	}
+	defer f.Close()
+
+	ef, err := elf.NewFile(f)
+	if err != nil {
+		return nil, fmt.Errorf("Parsing %s: %v", name, err)
+	}
+
+	var stextOffset *uint64
+	var pageAligned = func(addr uint64) bool { return addr%4096 == 0 }
+	if strings.Contains(name, "vmlinux") || !pageAligned(start) || !pageAligned(limit) || !pageAligned(offset) {
+		// Reading all Symbols is expensive, and we only rarely need it so
+		// we don't want to do it every time.  But if _stext happens to be
+		// page-aligned but isn't the same as Vaddr, we would symbolize
+		// wrong.  So if the name the addresses aren't page aligned, or if
+		// the name is "vmlinux" we read _stext.  We can be wrong if: (1)
+		// someone passes a kernel path that doesn't contain "vmlinux" AND
+		// (2) _stext is page-aligned AND (3) _stext is not at Vaddr
+		symbols, err := ef.Symbols()
+		if err != nil {
+			return nil, err
+		}
+		for _, s := range symbols {
+			if s.Name == "_stext" {
+				// The kernel may use _stext as the mapping start address.
+				stextOffset = &s.Value
+				break
+			}
+		}
+	}
+
+	base, err := elfexec.GetBase(&ef.FileHeader, nil, stextOffset, start, limit, offset)
+	if err != nil {
+		return nil, fmt.Errorf("Could not identify base for %s: %v", name, err)
+	}
+
+	// Find build ID, while we have the file open.
+	buildID := ""
+	if id, err := elfexec.GetBuildID(f); err == nil {
+		buildID = fmt.Sprintf("%x", id)
+	}
+	if b.fast {
+		return &fileNM{file: file{b, name, base, buildID}}, nil
+	}
+	return &fileAddr2Line{file: file{b, name, base, buildID}}, nil
+}
+
+// file implements the binutils.ObjFile interface.
+type file struct {
+	b       *Binutils
+	name    string
+	base    uint64
+	buildID string
+}
+
+func (f *file) Name() string {
+	return f.name
+}
+
+func (f *file) Base() uint64 {
+	return f.base
+}
+
+func (f *file) BuildID() string {
+	return f.buildID
+}
+
+func (f *file) SourceLine(addr uint64) ([]plugin.Frame, error) {
+	return []plugin.Frame{}, nil
+}
+
+func (f *file) Close() error {
+	return nil
+}
+
+func (f *file) Symbols(r *regexp.Regexp, addr uint64) ([]*plugin.Sym, error) {
+	return findSymbols(f.b.nm, f.name, r, addr)
+}
+
+// fileNM implements the binutils.ObjFile interface, using 'nm' to map
+// addresses to symbols (without file/line number information). It is
+// faster than fileAddr2Line.
+type fileNM struct {
+	file
+	addr2linernm *addr2LinerNM
+}
+
+func (f *fileNM) SourceLine(addr uint64) ([]plugin.Frame, error) {
+	if f.addr2linernm == nil {
+		addr2liner, err := newAddr2LinerNM(f.b.nm, f.name, f.base)
+		if err != nil {
+			return nil, err
+		}
+		f.addr2linernm = addr2liner
+	}
+	return f.addr2linernm.addrInfo(addr)
+}
+
+// fileAddr2Line implements the binutils.ObjFile interface, using
+// 'addr2line' to map addresses to symbols (with file/line number
+// information). It can be slow for large binaries with debug
+// information.
+type fileAddr2Line struct {
+	file
+	addr2liner *addr2Liner
+}
+
+func (f *fileAddr2Line) SourceLine(addr uint64) ([]plugin.Frame, error) {
+	if f.addr2liner == nil {
+		addr2liner, err := newAddr2Liner(f.b.addr2line, f.name, f.base)
+		if err != nil {
+			return nil, err
+		}
+		f.addr2liner = addr2liner
+	}
+	return f.addr2liner.addrInfo(addr)
+}
+
+func (f *fileAddr2Line) Close() error {
+	if f.addr2liner != nil {
+		f.addr2liner.close()
+		f.addr2liner = nil
+	}
+	return nil
+}

src/internal/binutils/binutils_test.go

+// 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.
+
+package binutils
+
+import (
+	"fmt"
+	"testing"
+
+	"internal/plugin"
+)
+
+var testAddrMap = map[int]string{
+	1000: "_Z3fooid.clone2",
+	2000: "_ZNSaIiEC1Ev.clone18",
+	3000: "_ZNSt6vectorIS_IS_IiSaIiEESaIS1_EESaIS3_EEixEm",
+}
+
+func functionName(level int) (name string) {
+	if name = testAddrMap[level]; name != "" {
+		return name
+	}
+	return fmt.Sprintf("fun%d", level)
+}
+
+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)
+	}
+
+	for i := 1; i < 8; i++ {
+		addr := i*0x1000 + offset
+		s, err := a.addrInfo(uint64(addr))
+		if err != nil {
+			t.Fatalf("addrInfo(%#x): %v", addr, err)
+		}
+		if len(s) != i {
+			t.Fatalf("addrInfo(%#x): got len==%d, want %d", addr, len(s), i)
+		}
+		for l, f := range s {
+			level := (len(s) - l) * 1000
+			want := plugin.Frame{functionName(level), fmt.Sprintf("file%d", level), level}
+
+			if f != want {
+				t.Errorf("AddrInfo(%#x)[%d]: = %+v, want %+v", addr, l, f, want)
+			}
+		}
+	}
+	s, err := a.addrInfo(0xFFFF)
+	if err != nil {
+		t.Fatalf("addrInfo(0xFFFF): %v", err)
+	}
+	if len(s) != 0 {
+		t.Fatalf("AddrInfo(0xFFFF): got len==%d, want 0", len(s))
+	}
+	a.close()
+}
+
+func TestAddr2LinerLookup(t *testing.T) {
+	oddSizedMap := addr2LinerNM{
+		m: []symbolInfo{
+			{0x1000, "0x1000"},
+			{0x2000, "0x2000"},
+			{0x3000, "0x3000"},
+		},
+	}
+	evenSizedMap := addr2LinerNM{
+		m: []symbolInfo{
+			{0x1000, "0x1000"},
+			{0x2000, "0x2000"},
+			{0x3000, "0x3000"},
+			{0x4000, "0x4000"},
+		},
+	}
+	for _, a := range []*addr2LinerNM{
+		&oddSizedMap, &evenSizedMap,
+	} {
+		for address, want := range map[uint64]string{
+			0x1000: "0x1000",
+			0x1001: "0x1000",
+			0x1FFF: "0x1000",
+			0x2000: "0x2000",
+			0x2001: "0x2000",
+		} {
+			if got, _ := a.addrInfo(address); !checkAddress(got, address, want) {
+				t.Errorf("%x: got %v, want %s", address, got, want)
+			}
+		}
+	}
+}
+
+func checkAddress(got []plugin.Frame, address uint64, want string) bool {
+	if len(got) != 1 {
+		return false
+	}
+	return got[0].Func == want
+}

src/internal/binutils/disasm.go

+// 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.
+
+package binutils
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os/exec"
+	"regexp"
+	"strconv"
+
+	"internal/plugin"
+	"golang/demangle"
+)
+
+var (
+	nmOutputRE            = regexp.MustCompile(`^\s*([[:xdigit:]]+)\s+(.)\s+(.*)`)
+	objdumpAsmOutputRE    = regexp.MustCompile(`^\s*([[:xdigit:]]+):\s+(.*)`)
+	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)
+	}
+
+	// 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)
+	for symAddr, name, err := nextSymbol(buf); err == nil; symAddr, name, err = nextSymbol(buf) {
+		if err != nil {
+			return nil, err
+		}
+		if start == symAddr {
+			names = append(names, name)
+			continue
+		}
+		if match := matchSymbol(names, start, symAddr-1, r, address); match != nil {
+			symbols = append(symbols, &plugin.Sym{match, file, start, symAddr - 1})
+		}
+		names, start = []string{name}, symAddr
+	}
+
+	return symbols, nil
+}
+
+// matchSymbol checks if a symbol is to be selected by checking its
+// name to the regexp and optionally its address. It returns the name(s)
+// to be used for the matched symbol, or nil if no match
+func matchSymbol(names []string, start, end uint64, r *regexp.Regexp, address uint64) []string {
+	if address != 0 && address >= start && address <= end {
+		return names
+	}
+	for _, name := range names {
+		if r.MatchString(name) {
+			return []string{name}
+		}
+
+		// Match all possible demangled versions of the name.
+		for _, o := range [][]demangle.Option{
+			{demangle.NoClones},
+			{demangle.NoParams},
+			{demangle.NoParams, demangle.NoTemplateParams},
+		} {
+			if demangled, err := demangle.ToString(name, o...); err == nil && r.MatchString(demangled) {
+				return []string{demangled}
+			}
+		}
+	}
+	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)
+	file, line := "", 0
+	var assembly []plugin.Inst
+	for {
+		input, err := buf.ReadString('\n')
+		if err != nil {
+			if err != io.EOF {
+				return nil, err
+			}
+			if input == "" {
+				break
+			}
+		}
+
+		if fields := objdumpAsmOutputRE.FindStringSubmatch(input); len(fields) == 3 {
+			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,
+					})
+				continue
+			}
+		}
+		if fields := objdumpOutputFileLine.FindStringSubmatch(input); len(fields) == 3 {
+			if l, err := strconv.ParseUint(fields[2], 10, 32); err == nil {
+				file, line = fields[1], int(l)
+			}
+		}
+	}
+
+	return assembly, nil
+}
+
+// nextSymbol parses the nm output to find the next symbol listed.
+// Skips over any output it cannot recognize.
+func nextSymbol(buf *bytes.Buffer) (uint64, string, error) {
+	for {
+		line, err := buf.ReadString('\n')
+		if err != nil {
+			if err != io.EOF || line == "" {
+				return 0, "", err
+			}
+		}
+
+		if fields := nmOutputRE.FindStringSubmatch(line); len(fields) == 4 {
+			if address, err := strconv.ParseUint(fields[1], 16, 64); err == nil {
+				return address, fields[3], nil
+			}
+		}
+	}
+}

src/internal/binutils/disasm_test.go

+// 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.
+
+package binutils
+
+import (
+	"fmt"
+	"regexp"
+	"testing"
+
+	"internal/plugin"
+)
+
+// TestFindSymbols tests the FindSymbols routine by using a fake nm
+// script.
+func TestFindSymbols(t *testing.T) {
+	type testcase struct {
+		query string
+		want  []plugin.Sym
+	}
+
+	testcases := []testcase{
+		{
+			"line.*[AC]",
+			[]plugin.Sym{
+				{[]string{"lineA001"}, "object.o", 0x1000, 0x1FFF},
+				{[]string{"line200A"}, "object.o", 0x2000, 0x2FFF},
+				{[]string{"lineB00C"}, "object.o", 0x3000, 0x3FFF},
+			},
+		},
+		{
+			"Dumb::operator",
+			[]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)
+		if err != nil {
+			t.Fatalf("%q: findSymbols: %v", tc.query, err)
+		}
+		if err := checkSymbol(syms, tc.want); err != nil {
+			t.Errorf("%q: %v", tc.query, err)
+		}
+	}
+}
+
+func checkSymbol(got []*plugin.Sym, want []plugin.Sym) error {
+	if len(got) != len(want) {
+		return fmt.Errorf("unexpected number of symbols %d (want %d)\n", len(got), len(want))
+	}
+
+	for i, g := range got {
+		w := want[i]
+		if len(g.Name) != len(w.Name) {
+			return fmt.Errorf("names, got %d, want %d", len(g.Name), len(w.Name))
+		}
+		for n := range g.Name {
+			if g.Name[n] != w.Name[n] {
+				return fmt.Errorf("name %d, got %q, want %q", n, g.Name[n], w.Name[n])
+			}
+		}
+		if g.File != w.File {
+			return fmt.Errorf("filename, got %q, want %q", g.File, w.File)
+		}
+		if g.Start != w.Start {
+			return fmt.Errorf("start address, got %#x, want %#x", g.Start, w.Start)
+		}
+		if g.End != w.End {
+			return fmt.Errorf("end address, got %#x, want %#x", g.End, w.End)
+		}
+	}
+	return nil
+}
+
+// TestFunctionAssembly tests the FunctionAssembly routine by using a
+// fake objdump script.
+func TestFunctionAssembly(t *testing.T) {
+	type testcase struct {
+		s    plugin.Sym
+		want []plugin.Inst
+	}
+	testcases := []testcase{
+		{
+			plugin.Sym{[]string{"symbol1"}, "", 0x1000, 0x1FFF},
+			[]plugin.Inst{
+				{0x1000, "instruction one", "", 0},
+				{0x1001, "instruction two", "", 0},
+				{0x1002, "instruction three", "", 0},
+				{0x1003, "instruction four", "", 0},
+			},
+		},
+		{
+			plugin.Sym{[]string{"symbol2"}, "", 0x2000, 0x2FFF},
+			[]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)
+		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))
+		}
+		for i := range insns {
+			if insns[i] != tc.want[i] {
+				t.Errorf("Expected symbol %v, got %v\n", tc.want[i], insns[i])
+			}
+		}
+	}
+}

src/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

src/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

src/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

src/internal/driver/cli.go

+// 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.
+
+package driver
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"internal/binutils"
+	"internal/plugin"
+)
+
+type source struct {
+	Sources  []string
+	ExecName string
+	BuildID  string
+	Base     []string
+
+	Seconds   int
+	Timeout   int
+	Symbolize string
+}
+
+// Parse parses the command lines through the specified flags package
+// and returns the source of the profile and optionally the command
+// for the kind of report to generate (nil for interactive use).
+func parseFlags(o *plugin.Options) (*source, []string, error) {
+	flag := o.Flagset
+	// Comparisons.
+	flagBase := flag.StringList("base", "", "Source for base profile for comparison")
+	// Internal options.
+	flagSymbolize := flag.String("symbolize", "", "Options for profile symbolization")
+	flagBuildID := flag.String("buildid", "", "Override build id for first mapping")
+	// CPU profile options
+	flagSeconds := flag.Int("seconds", -1, "Length of time for dynamic profiles")
+	// Heap profile options
+	flagInUseSpace := flag.Bool("inuse_space", false, "Display in-use memory size")
+	flagInUseObjects := flag.Bool("inuse_objects", false, "Display in-use object counts")
+	flagAllocSpace := flag.Bool("alloc_space", false, "Display allocated memory size")
+	flagAllocObjects := flag.Bool("alloc_objects", false, "Display allocated object counts")
+	// Contention profile options
+	flagTotalDelay := flag.Bool("total_delay", false, "Display total delay at each region")
+	flagContentions := flag.Bool("contentions", false, "Display number of delays at each region")
+	flagMeanDelay := flag.Bool("mean_delay", false, "Display mean delay at each region")
+	flagTools := flag.String("tools", os.Getenv("PPROF_TOOLS"), "Path for object tool pathnames")
+
+	flagTimeout := flag.Int("timeout", -1, "Timeout in seconds for fetching a profile")
+
+	// Flags used during command processing
+	installedFlags := installFlags(flag)
+
+	flagCommands := make(map[string]*bool)
+	flagParamCommands := make(map[string]*string)
+	for name, cmd := range pprofCommands {
+		if cmd.hasParam {
+			flagParamCommands[name] = flag.String(name, "", "Generate a report in "+name+" format, matching regexp")
+		} else {
+			flagCommands[name] = flag.Bool(name, false, "Generate a report in "+name+" format")
+		}
+	}
+
+	args := flag.Parse(func() {
+		o.UI.Print(usageMsgHdr +
+			usage(true) +
+			usageMsgSrc +
+			flag.ExtraUsage() +
+			usageMsgVars)
+	})
+	if len(args) == 0 {
+		return nil, nil, fmt.Errorf("no profile source specified")
+	}
+
+	var execName string
+	// Recognize first argument as an executable or buildid override.
+	if len(args) > 1 {
+		arg0 := args[0]
+		if file, err := o.Obj.Open(arg0, 0, ^uint64(0), 0); err == nil {
+			file.Close()
+			execName = arg0
+			args = args[1:]
+		} else if *flagBuildID == "" && isBuildID(arg0) {
+			*flagBuildID = arg0
+			args = args[1:]
+		}
+	}
+
+	// Report conflicting options
+	if err := updateFlags(installedFlags); err != nil {
+		return nil, nil, err
+	}
+
+	cmd, err := outputFormat(flagCommands, flagParamCommands)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	si := pprofVariables["sample_index"].value
+	si = sampleIndex(flagTotalDelay, si, "delay", "-total_delay", o.UI)
+	si = sampleIndex(flagMeanDelay, si, "delay", "-mean_delay", o.UI)
+	si = sampleIndex(flagContentions, si, "contentions", "-contentions", o.UI)
+	si = sampleIndex(flagInUseSpace, si, "inuse_space", "-inuse_space", o.UI)
+	si = sampleIndex(flagInUseObjects, si, "inuse_objects", "-inuse_objects", o.UI)
+	si = sampleIndex(flagAllocSpace, si, "alloc_space", "-alloc_space", o.UI)
+	si = sampleIndex(flagAllocObjects, si, "alloc_objects", "-alloc_objects", o.UI)
+	pprofVariables.set("sample_index", si)
+
+	if *flagMeanDelay {
+		pprofVariables.set("mean", "true")
+	}
+
+	source := &source{
+		Sources:   args,
+		ExecName:  execName,
+		BuildID:   *flagBuildID,
+		Seconds:   *flagSeconds,
+		Timeout:   *flagTimeout,
+		Symbolize: *flagSymbolize,
+	}
+
+	for _, s := range *flagBase {
+		if *s != "" {
+			source.Base = append(source.Base, *s)
+		}
+	}
+
+	if bu, ok := o.Obj.(*binutils.Binutils); ok {
+		bu.SetTools(*flagTools)
+	}
+	return source, cmd, nil
+}
+
+// installFlags creates command line flags for pprof variables.
+func installFlags(flag plugin.FlagSet) flagsInstalled {
+	f := flagsInstalled{
+		ints:    make(map[string]*int),
+		bools:   make(map[string]*bool),
+		floats:  make(map[string]*float64),
+		strings: make(map[string]*string),
+	}
+	for n, v := range pprofVariables {
+		switch v.kind {
+		case boolKind:
+			if v.group != "" {
+				// Set all radio variables to false to identify conflicts.
+				f.bools[n] = flag.Bool(n, false, v.help)
+			} else {
+				f.bools[n] = flag.Bool(n, v.boolValue(), v.help)
+			}
+		case intKind:
+			f.ints[n] = flag.Int(n, v.intValue(), v.help)
+		case floatKind:
+			f.floats[n] = flag.Float64(n, v.floatValue(), v.help)
+		case stringKind:
+			f.strings[n] = flag.String(n, v.value, v.help)
+		}
+	}
+	return f
+}
+
+// updateFlags updates the pprof variables according to the flags
+// parsed in the command line.
+func updateFlags(f flagsInstalled) error {
+	vars := pprofVariables
+	groups := map[string]string{}
+	for n, v := range f.bools {
+		vars.set(n, fmt.Sprint(*v))
+		if *v {
+			g := vars[n].group
+			if g != "" && groups[g] != "" {
+				return fmt.Errorf("conflicting options %q and %q set", n, groups[g])
+			}
+			groups[g] = n
+		}
+	}
+	for n, v := range f.ints {
+		vars.set(n, fmt.Sprint(*v))
+	}
+	for n, v := range f.floats {
+		vars.set(n, fmt.Sprint(*v))
+	}
+	for n, v := range f.strings {
+		vars.set(n, *v)
+	}
+	return nil
+}
+
+type flagsInstalled struct {
+	ints    map[string]*int
+	bools   map[string]*bool
+	floats  map[string]*float64
+	strings map[string]*string
+}
+
+// isBuildID determines if the profile may contain a build ID, by
+// checking that it is a string of hex digits.
+func isBuildID(id string) bool {
+	return strings.Trim(id, "0123456789abcdefABCDEF") == ""
+}
+
+func sampleIndex(flag *bool, si string, sampleType, option string, ui plugin.UI) string {
+	if *flag {
+		if si == "" {
+			return sampleType
+		}
+		ui.PrintErr("Multiple value selections, ignoring ", option)
+	}
+	return si
+}
+
+func outputFormat(bcmd map[string]*bool, acmd map[string]*string) (cmd []string, err error) {
+	for n, b := range bcmd {
+		if *b {
+			if cmd != nil {
+				return nil, fmt.Errorf("must set at most one output format")
+			}
+			cmd = []string{n}
+		}
+	}
+	for n, s := range acmd {
+		if *s != "" {
+			if cmd != nil {
+				return nil, fmt.Errorf("must set at most one output format")
+			}
+			cmd = []string{n, *s}
+		}
+	}
+	return cmd, nil
+}
+
+var usageMsgHdr = "usage: pprof [options] [-base source] [binary] <source> ...\n"
+
+var usageMsgSrc = "\n\n" +
+	"  Source options:\n" +
+	"    -seconds              Duration for time-based profile collection\n" +
+	"    -timeout              Timeout in seconds for profile collection\n" +
+	"    -buildid              Override build id for main binary\n" +
+	"    -base source          Source of profile to use as baseline\n" +
+	"    profile.pb.gz         Profile in compressed protobuf format\n" +
+	"    legacy_profile        Profile in legacy pprof format\n" +
+	"    http://host/profile   URL for profile handler to retrieve\n" +
+	"    -symbolize=           Controls source of symbol information\n" +
+	"      none                  Do not attempt symbolization\n" +
+	"      local                 Examine only local binaries\n" +
+	"      fastlocal             Only get function names from local binaries\n" +
+	"      remote                Do not examine local binaries\n" +
+	"      force                 Force re-symbolization\n" +
+	"    Binary                  Local path or build id of binary for symbolization\n"
+
+var usageMsgVars = "\n\n" +
+	"  Misc options:\n" +
+	"   -tools                 Search path for object tools\n" +
+	"\n" +
+	"  Environment Variables:\n" +
+	"   PPROF_TMPDIR       Location for temporary files (default $HOME/pprof)\n" +
+	"   PPROF_TOOLS        Search path for object-level tools\n" +
+	"   PPROF_BINARY_PATH  Search path for local binary files\n" +
+	"                      default: $HOME/pprof/binaries\n" +
+	"                      finds binaries by $name and $buildid/$name\n"

src/internal/driver/commands.go

+// 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.
+
+package driver
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"internal/plugin"
+	"internal/report"
+	"profile"
+	"svg"
+)
+
+// commands describes the commands accepted by pprof.
+type commands map[string]*command
+
+// command describes the actions for a pprof command. Includes a
+// function for command-line completion, the report format to use
+// during report generation, any postprocessing functions, and whether
+// the command expects a regexp parameter (typically a function name).
+type command struct {
+	format      int           // report format to generate
+	postProcess PostProcessor // postprocessing to run on report
+	hasParam    bool          // collect a parameter from the CLI
+	description string        // single-line description text saying what the command does
+	usage       string        // multi-line help text saying how the command is used
+}
+
+// help returns a help string for a command.
+func (c *command) help(name string) string {
+	message := c.description + "\n"
+	if c.usage != "" {
+		message += "  Usage:\n"
+		lines := strings.Split(c.usage, "\n")
+		for _, line := range lines {
+			message += fmt.Sprintf("    %s\n", line)
+		}
+	}
+	return message + "\n"
+}
+
+func AddCommand(cmd string, format int, post PostProcessor, desc, usage string) {
+	pprofCommands[cmd] = &command{format, post, false, desc, usage}
+}
+
+// PostProcessor is a function that applies post-processing to the report output
+type PostProcessor func(input []byte, output io.Writer, ui plugin.UI) error
+
+// WaitForVisualizer makes pprof wait for visualizers to complete
+// before continuing, returning any errors.
+var waitForVisualizer = true
+
+// pprofCommands are the report generation commands recognized by pprof.
+var pprofCommands = commands{
+	// Commands that require no post-processing.
+	"tags":     {report.Tags, nil, false, "Outputs all tags in the profile", "tags [tag_regex]* [-ignore_regex]* [>file]\nList tags with key:value matching tag_regex and exclude ignore_regex."},
+	"raw":      {report.Raw, nil, false, "Outputs a text representation of the raw profile", ""},
+	"dot":      {report.Dot, nil, false, "Outputs a graph in DOT format", reportHelp("dot", false, true)},
+	"top":      {report.Text, nil, false, "Outputs top entries in text form", reportHelp("top", true, true)},
+	"tree":     {report.Tree, nil, false, "Outputs a text rendering of call graph", reportHelp("tree", true, true)},
+	"text":     {report.Text, nil, false, "Outputs top entries in text form", reportHelp("text", true, true)},
+	"traces":   {report.Traces, nil, false, "Outputs all profile samples in text form", ""},
+	"topproto": {report.TopProto, awayFromTTY("pb.gz"), false, "Outputs top entries in compressed protobuf format", ""},
+	"disasm":   {report.Dis, nil, true, "Output assembly listings annotated with samples", listHelp("disasm", true)},
+	"list":     {report.List, nil, true, "Output annotated source for functions matching regexp", listHelp("list", false)},
+	"peek":     {report.Tree, nil, true, "Output callers/callees of functions matching regexp", "peek func_regex\nDisplay callers and callees of functions matching func_regex."},
+
+	// Save binary formats to a file
+	"callgrind": {report.Callgrind, awayFromTTY("callgraph.out"), false, "Outputs a graph in callgrind format", reportHelp("callgrind", false, true)},
+	"proto":     {report.Proto, awayFromTTY("pb.gz"), false, "Outputs the profile in compressed protobuf format", ""},
+
+	// Generate report in DOT format and postprocess with dot
+	"gif": {report.Dot, invokeDot("gif"), false, "Outputs a graph image in GIF format", reportHelp("gif", false, true)},
+	"pdf": {report.Dot, invokeDot("pdf"), false, "Outputs a graph in PDF format", reportHelp("pdf", false, true)},
+	"png": {report.Dot, invokeDot("png"), false, "Outputs a graph image in PNG format", reportHelp("png", false, true)},
+	"ps":  {report.Dot, invokeDot("ps"), false, "Outputs a graph in PS format", reportHelp("ps", false, true)},
+
+	// Save SVG output into a file
+	"svg": {report.Dot, saveSVGToFile(), false, "Outputs a graph in SVG format", reportHelp("svg", false, true)},
+
+	// Visualize postprocessed dot output
+	"eog":    {report.Dot, invokeVisualizer(invokeDot("svg"), "svg", []string{"eog"}), false, "Visualize graph through eog", reportHelp("eog", false, false)},
+	"evince": {report.Dot, invokeVisualizer(invokeDot("pdf"), "pdf", []string{"evince"}), false, "Visualize graph through evince", reportHelp("evince", false, false)},
+	"gv":     {report.Dot, invokeVisualizer(invokeDot("ps"), "ps", []string{"gv --noantialias"}), false, "Visualize graph through gv", reportHelp("gv", false, false)},
+	"web":    {report.Dot, invokeVisualizer(saveSVGToFile(), "svg", browsers()), false, "Visualize graph through web browser", reportHelp("web", false, false)},
+
+	// Visualize callgrind output
+	"kcachegrind": {report.Callgrind, invokeVisualizer(nil, "grind", kcachegrind), false, "Visualize report in KCachegrind", reportHelp("kcachegrind", false, false)},
+
+	// Visualize HTML directly generated by report.
+	"weblist": {report.WebList, invokeVisualizer(awayFromTTY("html"), "html", browsers()), true, "Display annotated source in a web browser", listHelp("weblist", false)},
+}
+
+// pprofVariables are the configuration parameters that affect the
+// reported generated by pprof.
+var pprofVariables = variables{
+	// Filename for file-based output formats, stdout by default.
+	"output": &variable{stringKind, "", "", helpText("Output filename for file-based outputs")},
+
+	// Comparisons.
+	"drop_negative": &variable{boolKind, "f", "", helpText(
+		"Ignore negative differences",
+		"Do not show any locations with values <0.")},
+
+	// Comparisons.
+	"positive_percentages": &variable{boolKind, "f", "", helpText(
+		"Ignore negative samples when computing percentages",
+		" Do not count negative samples when computing the total value",
+		" of the profile, used to compute percentages. If set, and the -base",
+		" option is used, percentages reported will be computed against the",
+		" main profile, ignoring the base profile.")},
+
+	// Graph handling options.
+	"call_tree": &variable{boolKind, "f", "", helpText(
+		"Create a context-sensitive call tree",
+		"Treat locations reached through different paths as separate.")},
+
+	// Display options.
+	"relative_percentages": &variable{boolKind, "f", "", helpText(
+		"Show percentages relative to focused subgraph",
+		"If unset, percentages are relative to full graph before focusing",
+		"to facilitate comparison with original graph.")},
+	"unit": &variable{stringKind, "minimum", "", helpText(
+		"Measurement units to display",
+		"Scale the sample values to this unit.",
+		" For time-based profiles, use seconds, milliseconds, nanoseconds, etc.",
+		" For memory profiles, use megabytes, kiloyes, bytes, etc.",
+		" auto will scale each value independently to the most natural unit.")},
+	"compact_labels": &variable{boolKind, "f", "", "Show minimal headers"},
+
+	// Filtering options
+	"nodecount": &variable{intKind, "-1", "", helpText(
+		"Max number of nodes to show",
+		"Uses heuristics to limit the number of locations to be displayed.",
+		"On graphs, dotted edges represent paths through nodes that have been removed.")},
+	"nodefraction": &variable{floatKind, "0.005", "", "Hide nodes below <f>*total"},
+	"edgefraction": &variable{floatKind, "0.001", "", "Hide edges below <f>*total"},
+	"trim": &variable{boolKind, "t", "", helpText(
+		"Honor nodefraction/edgefraction/nodecount defaults",
+		"Set to false to get the full profile, without any trimming.")},
+	"focus": &variable{stringKind, "", "", helpText(
+		"Restricts to samples going through a node matching regexp",
+		"Discard samples that do not include a node matching this regexp.",
+		"Matching includes the function name, filename or object name.")},
+	"ignore": &variable{stringKind, "", "", helpText(
+		"Skips paths going through any nodes matching regexp",
+		"If set, discard samples that include a node matching this regexp.",
+		"Matching includes the function name, filename or object name.")},
+	"prune_from": &variable{stringKind, "", "", helpText(
+		"Drops any functions below the matched frame.",
+		"If set, any frames matching the specified regexp and any frames",
+		"below it will be dropped from each sample.")},
+	"hide": &variable{stringKind, "", "", helpText(
+		"Skips nodes matching regexp",
+		"Discard nodes that match this location.",
+		"Other nodes from samples that include this location will be shown.",
+		"Matching includes the function name, filename or object name.")},
+	"show": &variable{stringKind, "", "", helpText(
+		"Only show nodes matching regexp",
+		"If set, only show nodes that match this location.",
+		"Matching includes the function name, filename or object name.")},
+	"tagfocus": &variable{stringKind, "", "", helpText(
+		"Restrict to samples with tags in range or matched by regexp",
+		"Discard samples that do not include a node with a tag matching this regexp.")},
+	"tagignore": &variable{stringKind, "", "", helpText(
+		"Discard samples with tags in range or matched by regexp",
+		"Discard samples that do include a node with a tag matching this regexp.")},
+
+	// Heap profile options
+	"divide_by": &variable{floatKind, "1", "", helpText(
+		"Ratio to divide all samples before visualization",
+		"Divide all samples values by a constant, eg the number of processors or jobs.")},
+	"mean": &variable{boolKind, "f", "", helpText(
+		"Average sample value over first value (count)",
+		"For memory profiles, report average memory per allocation.",
+		"For time-based profiles, report average time per event.")},
+	"sample_index": &variable{stringKind, "", "", helpText(
+		"Sample value to report",
+		"Profiles contain multiple values per sample.",
+		"Use sample_value=index to select the ith value or select it by name.")},
+
+	// Data sorting criteria
+	"flat": &variable{boolKind, "t", "cumulative", helpText("Sort entries based on own weight")},
+	"cum":  &variable{boolKind, "f", "cumulative", helpText("Sort entries based on cumulative weight")},
+
+	// Output granularity
+	"functions": &variable{boolKind, "t", "granularity", helpText(
+		"Aggregate at the function level.",
+		"Takes into account the filename/lineno where the function was defined.")},
+	"functionnameonly": &variable{boolKind, "f", "granularity", helpText(
+		"Aggregate at the function level.",
+		"Ignores the filename/lineno where the function was defined.")},
+	"files": &variable{boolKind, "f", "granularity", "Aggregate at the file level."},
+	"lines": &variable{boolKind, "f", "granularity", "Aggregate at the source code line level."},
+	"addresses": &variable{boolKind, "f", "granularity", helpText(
+		"Aggregate at the function level.",
+		"Includes functions' addresses in the output.")},
+	"noinlines": &variable{boolKind, "f", "granularity", helpText(
+		"Aggregate at the function level.",
+		"Attributes inlined functions to their first out-of-line caller.")},
+	"addressnoinlines": &variable{boolKind, "f", "granularity", helpText(
+		"Aggregate at the function level, including functions' addresses in the output.",
+		"Attributes inlined functions to their first out-of-line caller.")},
+}
+
+func helpText(s ...string) string {
+	return strings.Join(s, "\n") + "\n"
+}
+
+// usage returns a string describing the pprof commands and variables.
+// if commandLine is set, the output reflect cli usage.
+func usage(commandLine bool) string {
+	var prefix string
+	if commandLine {
+		prefix = "-"
+	}
+	fmtHelp := func(c, d string) string {
+		return fmt.Sprintf("    %-16s %s", c, strings.SplitN(d, "\n", 2)[0])
+	}
+
+	var commands []string
+	for name, cmd := range pprofCommands {
+		commands = append(commands, fmtHelp(prefix+name, cmd.description))
+	}
+	sort.Strings(commands)
+
+	var help string
+	if commandLine {
+		help = "  Output formats (select only one):\n"
+	} else {
+		help = "  Commands:\n"
+		commands = append(commands, fmtHelp("quit/exit/^D", "Exit pprof"))
+	}
+
+	help = help + strings.Join(commands, "\n") + "\n\n" +
+		"  Options:\n"
+
+	// Print help for variables after sorting them.
+	// Collect radio variables by their group name to print them together.
+	radioOptions := make(map[string][]string)
+	var variables []string
+	for name, vr := range pprofVariables {
+		if vr.group != "" {
+			radioOptions[vr.group] = append(radioOptions[vr.group], name)
+			continue
+		}
+		variables = append(variables, fmtHelp(prefix+name, vr.help))
+	}
+	sort.Strings(variables)
+
+	help = help + strings.Join(variables, "\n") + "\n\n" +
+		"  Option groups (only set one per group):\n"
+
+	var radioStrings []string
+	for radio, ops := range radioOptions {
+		sort.Strings(ops)
+		s := []string{fmtHelp(radio, "")}
+		for _, op := range ops {
+			s = append(s, "  "+fmtHelp(prefix+op, pprofVariables[op].help))
+		}
+
+		radioStrings = append(radioStrings, strings.Join(s, "\n"))
+	}
+	sort.Strings(radioStrings)
+	return help + strings.Join(radioStrings, "\n")
+}
+
+func reportHelp(c string, cum, redirect bool) string {
+	h := []string{
+		c + " [n] [focus_regex]* [-ignore_regex]*",
+		"Include up to n samples",
+		"Include samples matching focus_regex, and exclude ignore_regex.",
+	}
+	if cum {
+		h[0] += " [-cum]"
+		h = append(h, "-cum sorts the output by cumulative weight")
+	}
+	if redirect {
+		h[0] += " >f"
+		h = append(h, "Optionally save the report on the file f")
+	}
+	return strings.Join(h, "\n")
+}
+
+func listHelp(c string, redirect bool) string {
+	h := []string{
+		c + "<func_regex|address> [-focus_regex]* [-ignore_regex]*",
+		"Include functions matching func_regex, or including the address specified.",
+		"Include samples matching focus_regex, and exclude ignore_regex.",
+	}
+	if redirect {
+		h[0] += " >f"
+		h = append(h, "Optionally save the report on the file f")
+	}
+	return strings.Join(h, "\n")
+}
+
+// browsers returns a list of commands to attempt for web visualization.
+func browsers() []string {
+	cmds := []string{"chrome", "google-chrome", "firefox"}
+	switch runtime.GOOS {
+	case "darwin":
+		return append(cmds, "/usr/bin/open")
+	case "windows":
+		return append(cmds, "cmd /c start")
+	default:
+		user_browser := os.Getenv("BROWSER")
+		if user_browser != "" {
+			cmds = append([]string{user_browser, "sensible-browser"}, cmds...)
+		} else {
+			cmds = append([]string{"sensible-browser"}, cmds...)
+		}
+		return append(cmds, "xdg-open")
+	}
+}
+
+var kcachegrind = []string{"kcachegrind"}
+
+// awayFromTTY saves the output in a file if it would otherwise go to
+// the terminal screen. This is used to avoid dumping binary data on
+// the screen.
+func awayFromTTY(format string) PostProcessor {
+	return func(input []byte, output io.Writer, ui plugin.UI) error {
+		if output == os.Stdout && ui.IsTerminal() {
+			tempFile, err := newTempFile("", "profile", "."+format)
+			if err != nil {
+				return err
+			}
+			ui.PrintErr("Generating report in ", tempFile.Name())
+			_, err = fmt.Fprint(tempFile, string(input))
+			return err
+		}
+		_, err := fmt.Fprint(output, string(input))
+		return err
+	}
+}
+
+func invokeDot(format string) PostProcessor {
+	divert := awayFromTTY(format)
+	return func(input []byte, output io.Writer, ui plugin.UI) error {
+		cmd := exec.Command("dot", "-T"+format)
+		var buf bytes.Buffer
+		cmd.Stdin, cmd.Stdout, cmd.Stderr = bytes.NewBuffer(input), &buf, os.Stderr
+		if err := cmd.Run(); err != nil {
+			return fmt.Errorf("Failed to execute dot. Is Graphviz installed? Error: %v", err)
+		}
+		return divert(buf.Bytes(), output, ui)
+	}
+}
+
+func saveSVGToFile() PostProcessor {
+	generateSVG := invokeDot("svg")
+	divert := awayFromTTY("svg")
+	return func(input []byte, output io.Writer, ui plugin.UI) error {
+		baseSVG := &bytes.Buffer{}
+		if err := generateSVG(input, baseSVG, ui); err != nil {
+			return err
+		}
+
+		return divert([]byte(svg.Massage(*baseSVG)), output, ui)
+	}
+}
+
+func invokeVisualizer(format PostProcessor, suffix string, visualizers []string) PostProcessor {
+	return func(input []byte, output io.Writer, ui plugin.UI) error {
+		if output != os.Stdout {
+			if format != nil {
+				return format(input, output, ui)
+			}
+			_, err := fmt.Fprint(output, string(input))
+			return err
+		}
+
+		tempFile, err := newTempFile(os.Getenv("PPROF_TMPDIR"), "pprof", "."+suffix)
+		if err != nil {
+			return err
+		}
+		deferDeleteTempFile(tempFile.Name())
+		if format != nil {
+			if err := format(input, tempFile, ui); err != nil {
+				return err
+			}
+		} else {
+			if _, err := fmt.Fprint(tempFile, string(input)); err != nil {
+				return err
+			}
+		}
+		tempFile.Close()
+		// Try visualizers until one is successful
+		for _, v := range visualizers {
+			// Separate command and arguments for exec.Command.
+			args := strings.Split(v, " ")
+			if len(args) == 0 {
+				continue
+			}
+			viewer := exec.Command(args[0], append(args[1:], tempFile.Name())...)
+			viewer.Stderr = os.Stderr
+			if err = viewer.Start(); err == nil {
+				// Wait for a second so that the visualizer has a chance to
+				// open the input file. This needs to be done even if we're
+				// waiting for the visualizer as it can be just a wrapper that
+				// spawns a browser tab and returns right away.
+				defer func(t <-chan time.Time) {
+					<-t
+				}(time.After(time.Second))
+				if waitForVisualizer {
+					return viewer.Wait()
+				}
+				return nil
+			}
+		}
+		return err
+	}
+}
+
+// locateSampleIndex returns the appropriate index for a value of sample index.
+// If numeric, it returns the number, otherwise it looks up the text in the
+// profile sample types.
+func locateSampleIndex(p *profile.Profile, sampleIndex string) (int, error) {
+	if sampleIndex == "" {
+		// By default select the last sample value
+		return len(p.SampleType) - 1, nil
+	}
+	if i, err := strconv.Atoi(sampleIndex); err == nil {
+		if i < 0 || i >= len(p.SampleType) {
+			return 0, fmt.Errorf("sample_index %s is outside the range [0..%d]", sampleIndex, len(p.SampleType)-1)
+		}
+		return i, nil
+	}
+
+	// Remove the inuse_ prefix to support legacy pprof options
+	// "inuse_space" and "inuse_objects" for profiles containing types
+	// "space" and "objects".
+	noInuse := strings.TrimPrefix(sampleIndex, "inuse_")
+	sampleTypes := make([]string, len(p.SampleType))
+	for i, t := range p.SampleType {
+		if t.Type == sampleIndex || t.Type == noInuse {
+			return i, nil
+		}
+		sampleTypes[i] = t.Type
+	}
+
+	return 0, fmt.Errorf("sample_index %q must be one of: %v", sampleIndex, sampleTypes)
+}
+
+// variables describe the configuration parameters recognized by pprof.
+type variables map[string]*variable
+
+// variable is a single configuration parameter.
+type variable struct {
+	kind  int    // How to interpret the value, must be one of the enums below.
+	value string // Effective value. Only values appropriate for the Kind should be set.
+	group string // boolKind variables with the same Group != "" cannot be set simultaneously.
+	help  string // Text describing the variable, in multiple lines separated by newline.
+}
+
+const (
+	// variable.kind must be one of these variables.
+	boolKind = iota
+	intKind
+	floatKind
+	stringKind
+)
+
+// set updates the value of a variable, checking that the value is
+// suitable for the variable Kind.
+func (vars variables) set(name, value string) error {
+	v := vars[name]
+	if v == nil {
+		return fmt.Errorf("no variable %s", name)
+	}
+	var err error
+	switch v.kind {
+	case boolKind:
+		var b bool
+		if b, err = stringToBool(value); err == nil {
+			if v.group != "" && b == false {
+				err = fmt.Errorf("%q can only be set to true", name)
+			}
+		}
+	case intKind:
+		_, err = strconv.Atoi(value)
+	case floatKind:
+		_, err = strconv.ParseFloat(value, 64)
+	}
+	if err != nil {
+		return err
+	}
+	vars[name].value = value
+	if group := vars[name].group; group != "" {
+		for vname, vvar := range vars {
+			if vvar.group == group && vname != name {
+				vvar.value = "f"
+			}
+		}
+	}
+	return err
+}
+
+// boolValue returns the value of a boolean variable.
+func (v *variable) boolValue() bool {
+	b, err := stringToBool(v.value)
+	if err != nil {
+		panic("unexpected value " + v.value + " for bool ")
+	}
+	return b
+}
+
+// intValue returns the value of an intKind variable.
+func (v *variable) intValue() int {
+	i, err := strconv.Atoi(v.value)
+	if err != nil {
+		panic("unexpected value " + v.value + " for int ")
+	}
+	return i
+}
+
+// floatValue returns the value of a Float variable.
+func (v *variable) floatValue() float64 {
+	f, err := strconv.ParseFloat(v.value, 64)
+	if err != nil {
+		panic("unexpected value " + v.value + " for float ")
+	}
+	return f
+}
+
+// stringValue returns a canonical representation for a variable.
+func (v *variable) stringValue() string {
+	switch v.kind {
+	case boolKind:
+		return fmt.Sprint(v.boolValue())
+	case intKind:
+		return fmt.Sprint(v.intValue())
+	case floatKind:
+		return fmt.Sprint(v.floatValue())
+	}
+	return v.value
+}
+
+func stringToBool(s string) (bool, error) {
+	switch strings.ToLower(s) {
+	case "true", "t", "yes", "y", "1", "":
+		return true, nil
+	case "false", "f", "no", "n", "0":
+		return false, nil
+	default:
+		return false, fmt.Errorf(`illegal value "%s" for bool variable`, s)
+	}
+}
+
+// makeCopy returns a duplicate of a set of shell variables.
+func (vars variables) makeCopy() variables {
+	varscopy := make(variables, len(vars))
+	for n, v := range vars {
+		vcopy := *v
+		varscopy[n] = &vcopy
+	}
+	return varscopy
+}

src/internal/driver/driver.go

+// 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.
+
+// Package driver implements the core pprof functionality. It can be
+// parameterized with a flag implementation, fetch and symbolize
+// mechanisms.
+package driver
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
+
+	"internal/plugin"
+	"profile"
+	"internal/report"
+)
+
+// PProf acquires a profile, and symbolizes it using a profile
+// manager. Then it generates a report formatted according to the
+// options selected through the flags package.
+func PProf(eo *plugin.Options) error {
+	// Remove any temporary files created during pprof processing.
+	defer cleanupTempFiles()
+
+	o := setDefaults(eo)
+
+	src, cmd, err := parseFlags(o)
+	if err != nil {
+		return err
+	}
+
+	p, err := fetchProfiles(src, o)
+	if err != nil {
+		return err
+	}
+
+	if cmd != nil {
+		return generateReport(p, cmd, pprofVariables, o)
+	}
+
+	return interactive(p, o)
+}
+
+func generateReport(p *profile.Profile, cmd []string, vars variables, o *plugin.Options) error {
+	p = p.Copy() // Prevent modification to the incoming profile.
+
+	var w io.Writer
+	switch output := vars["output"].value; output {
+	case "":
+		w = os.Stdout
+	default:
+		o.UI.PrintErr("Generating report in ", output)
+		outputFile, err := o.Writer.Open(output)
+		if err != nil {
+			return err
+		}
+		defer outputFile.Close()
+		w = outputFile
+	}
+
+	vars = applyCommandOverrides(cmd, vars)
+
+	// Delay focus after configuring report to get percentages on all samples.
+	relative := vars["relative_percentages"].boolValue()
+	if relative {
+		if err := applyFocus(p, vars, o.UI); err != nil {
+			return err
+		}
+	}
+	ropt, err := reportOptions(p, vars)
+	if err != nil {
+		return err
+	}
+	c := pprofCommands[cmd[0]]
+	if c == nil {
+		panic("unexpected nil command")
+	}
+	ropt.OutputFormat = c.format
+	post := c.postProcess
+	if len(cmd) == 2 {
+		s, err := regexp.Compile(cmd[1])
+		if err != nil {
+			return fmt.Errorf("parsing argument regexp %s: %v", cmd[1], err)
+		}
+		ropt.Symbol = s
+	}
+
+	rpt := report.New(p, ropt)
+	if !relative {
+		if err := applyFocus(p, vars, o.UI); err != nil {
+			return err
+		}
+	}
+
+	if err := aggregate(p, vars); err != nil {
+		return err
+	}
+
+	if post == nil {
+		return report.Generate(w, rpt, o.Obj)
+	}
+
+	// Capture output into buffer and send to postprocessing command.
+	buf := &bytes.Buffer{}
+	if err := report.Generate(buf, rpt, o.Obj); err != nil {
+		return err
+	}
+	return post(buf.Bytes(), w, o.UI)
+}
+
+func applyCommandOverrides(cmd []string, v variables) variables {
+	trim, focus, hide := v["trim"].boolValue(), true, true
+
+	switch cmd[0] {
+	case "proto", "raw":
+		trim, focus, hide = false, false, false
+		v.set("addresses", "t")
+	case "disasm", "weblist":
+		trim = false
+		v.set("addressnoinlines", "t")
+	case "peek":
+		trim, focus, hide = false, false, false
+	case "callgrind", "list":
+		v.set("nodecount", "0")
+		v.set("lines", "t")
+	case "text", "top", "topproto":
+		if v["nodecount"].intValue() == -1 {
+			v.set("nodecount", "0")
+		}
+	default:
+		if v["nodecount"].intValue() == -1 {
+			v.set("nodecount", "80")
+		}
+	}
+	if trim == false {
+		v.set("nodecount", "0")
+		v.set("nodefraction", "0")
+		v.set("edgefraction", "0")
+	}
+	if focus == false {
+		v.set("focus", "")
+		v.set("ignore", "")
+		v.set("tagfocus", "")
+		v.set("tagignore", "")
+	}
+	if hide == false {
+		v.set("hide", "")
+		v.set("show", "")
+	}
+	return v
+}
+
+func aggregate(prof *profile.Profile, v variables) error {
+	var inlines, function, filename, linenumber, address bool
+	switch {
+	case v["addresses"].boolValue():
+		return nil
+	case v["lines"].boolValue():
+		inlines = true
+		function = true
+		filename = true
+		linenumber = true
+	case v["files"].boolValue():
+		inlines = true
+		filename = true
+	case v["functions"].boolValue():
+		inlines = true
+		function = true
+		filename = true
+	case v["noinlines"].boolValue():
+		function = true
+		filename = true
+	case v["addressnoinlines"].boolValue():
+		function = true
+		filename = true
+		linenumber = true
+		address = true
+	case v["functionnameonly"].boolValue():
+		inlines = true
+		function = true
+	default:
+		return fmt.Errorf("unexpected granularity")
+	}
+	return prof.Aggregate(inlines, function, filename, linenumber, address)
+}
+
+func reportOptions(p *profile.Profile, vars variables) (*report.Options, error) {
+	si, mean := vars["sample_index"].value, vars["mean"].boolValue()
+	value, sample, err := sampleFormat(p, si, mean)
+	if err != nil {
+		return nil, err
+	}
+
+	stype := sample.Type
+	if mean {
+		stype = "mean_" + stype
+	}
+
+	if vars["divide_by"].floatValue() == 0 {
+		return nil, fmt.Errorf("zero divisor specified")
+	}
+
+	ropt := &report.Options{
+		CumSort:             vars["cum"].boolValue(),
+		CallTree:            vars["call_tree"].boolValue(),
+		DropNegative:        vars["drop_negative"].boolValue(),
+		PositivePercentages: vars["positive_percentages"].boolValue(),
+
+		CompactLabels: vars["compact_labels"].boolValue(),
+		Ratio:         1 / vars["divide_by"].floatValue(),
+
+		NodeCount:    vars["nodecount"].intValue(),
+		NodeFraction: vars["nodefraction"].floatValue(),
+		EdgeFraction: vars["edgefraction"].floatValue(),
+
+		SampleValue: value,
+		SampleType:  stype,
+		SampleUnit:  sample.Unit,
+
+		OutputUnit: vars["unit"].value,
+	}
+
+	if len(p.Mapping) > 0 {
+		ropt.Title = filepath.Base(p.Mapping[0].File)
+	}
+
+	return ropt, nil
+}
+
+type sampleValueFunc func([]int64) int64
+
+// sampleFormat returns a function to extract values out of a profile.Sample,
+// and the type/units of those values.
+func sampleFormat(p *profile.Profile, sampleIndex string, mean bool) (sampleValueFunc, *profile.ValueType, error) {
+	if len(p.SampleType) == 0 {
+		return nil, nil, fmt.Errorf("profile has no samples")
+	}
+	index, err := locateSampleIndex(p, sampleIndex)
+	if err != nil {
+		return nil, nil, err
+	}
+	if mean {
+		return meanExtractor(index), p.SampleType[index], nil
+	}
+	return valueExtractor(index), p.SampleType[index], nil
+}
+
+func valueExtractor(ix int) sampleValueFunc {
+	return func(v []int64) int64 {
+		return v[ix]
+	}
+}
+
+func meanExtractor(ix int) sampleValueFunc {
+	return func(v []int64) int64 {
+		if v[0] == 0 {
+			return 0
+		}
+		return v[ix] / v[0]
+	}
+}

src/internal/driver/driver_focus.go

+// 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.
+
+package driver
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"internal/measurement"
+	"internal/plugin"
+	"profile"
+)
+
+var tagFilterRangeRx = regexp.MustCompile("([[:digit:]]+)([[:alpha:]]+)")
+
+// applyFocus filters samples based on the focus/ignore options
+func applyFocus(prof *profile.Profile, v variables, ui plugin.UI) error {
+	focus, err := compileRegexOption("focus", v["focus"].value, nil)
+	ignore, err := compileRegexOption("ignore", v["ignore"].value, err)
+	hide, err := compileRegexOption("hide", v["hide"].value, err)
+	show, err := compileRegexOption("show", v["show"].value, err)
+	tagfocus, err := compileTagFilter("tagfocus", v["tagfocus"].value, ui, err)
+	tagignore, err := compileTagFilter("tagignore", v["tagignore"].value, ui, err)
+	prunefrom, err := compileRegexOption("prune_from", v["prune_from"].value, err)
+	if err != nil {
+		return err
+	}
+
+	fm, im, hm, hnm := prof.FilterSamplesByName(focus, ignore, hide, show)
+	warnNoMatches(focus == nil || fm, "Focus", ui)
+	warnNoMatches(ignore == nil || im, "Ignore", ui)
+	warnNoMatches(hide == nil || hm, "Hide", ui)
+	warnNoMatches(show == nil || hnm, "Show", ui)
+
+	tfm, tim := prof.FilterSamplesByTag(tagfocus, tagignore)
+	warnNoMatches(tagfocus == nil || tfm, "TagFocus", ui)
+	warnNoMatches(tagignore == nil || tim, "TagIgnore", ui)
+
+	if prunefrom != nil {
+		prof.PruneFrom(prunefrom)
+	}
+	return nil
+}
+
+func compileRegexOption(name, value string, err error) (*regexp.Regexp, error) {
+	if value == "" || err != nil {
+		return nil, err
+	}
+	rx, err := regexp.Compile(value)
+	if err != nil {
+		return nil, fmt.Errorf("parsing %s regexp: %v", name, err)
+	}
+	return rx, nil
+}
+
+func compileTagFilter(name, value string, ui plugin.UI, err error) (func(*profile.Sample) bool, error) {
+	if value == "" || err != nil {
+		return nil, err
+	}
+	if numFilter := parseTagFilterRange(value); numFilter != nil {
+		ui.PrintErr(name, ":Interpreted '", value, "' as range, not regexp")
+		return func(s *profile.Sample) bool {
+			for key, vals := range s.NumLabel {
+				for _, val := range vals {
+					if numFilter(val, key) {
+						return true
+					}
+				}
+			}
+			return false
+		}, nil
+	}
+	var rfx []*regexp.Regexp
+	for _, tagf := range strings.Split(value, ",") {
+		fx, err := regexp.Compile(tagf)
+		if err != nil {
+			return nil, fmt.Errorf("parsing %s regexp: %v", name, err)
+		}
+		rfx = append(rfx, fx)
+	}
+	return func(s *profile.Sample) bool {
+	matchedrx:
+		for _, rx := range rfx {
+			for key, vals := range s.Label {
+				for _, val := range vals {
+					if rx.MatchString(key + ":" + val) {
+						continue matchedrx
+					}
+				}
+			}
+			return false
+		}
+		return true
+	}, nil
+}
+
+// parseTagFilterRange returns a function to checks if a value is
+// contained on the range described by a string. It can recognize
+// strings of the form:
+// "32kb" -- matches values == 32kb
+// ":64kb" -- matches values <= 64kb
+// "4mb:" -- matches values >= 4mb
+// "12kb:64mb" -- matches values between 12kb and 64mb (both included).
+func parseTagFilterRange(filter string) func(int64, string) bool {
+	ranges := tagFilterRangeRx.FindAllStringSubmatch(filter, 2)
+	if len(ranges) == 0 {
+		return nil // No ranges were identified
+	}
+	v, err := strconv.ParseInt(ranges[0][1], 10, 64)
+	if err != nil {
+		panic(fmt.Errorf("Failed to parse int %s: %v", ranges[0][1], err))
+	}
+	scaledValue, unit := measurement.Scale(v, ranges[0][2], ranges[0][2])
+	if len(ranges) == 1 {
+		switch match := ranges[0][0]; filter {
+		case match:
+			return func(v int64, u string) bool {
+				sv, su := measurement.Scale(v, u, unit)
+				return su == unit && sv == scaledValue
+			}
+		case match + ":":
+			return func(v int64, u string) bool {
+				sv, su := measurement.Scale(v, u, unit)
+				return su == unit && sv >= scaledValue
+			}
+		case ":" + match:
+			return func(v int64, u string) bool {
+				sv, su := measurement.Scale(v, u, unit)
+				return su == unit && sv <= scaledValue
+			}
+		}
+		return nil
+	}
+	if filter != ranges[0][0]+":"+ranges[1][0] {
+		return nil
+	}
+	if v, err = strconv.ParseInt(ranges[1][1], 10, 64); err != nil {
+		panic(fmt.Errorf("Failed to parse int %s: %v", ranges[1][1], err))
+	}
+	scaledValue2, unit2 := measurement.Scale(v, ranges[1][2], unit)
+	if unit != unit2 {
+		return nil
+	}
+	return func(v int64, u string) bool {
+		sv, su := measurement.Scale(v, u, unit)
+		return su == unit && sv >= scaledValue && sv <= scaledValue2
+	}
+}
+
+func warnNoMatches(match bool, option string, ui plugin.UI) {
+	if !match {
+		ui.PrintErr(option + " expression matched no samples")
+	}
+}

src/internal/driver/fetch.go

+// 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.
+
+package driver
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strconv"
+	"sync"
+	"time"
+
+	"internal/measurement"
+	"internal/plugin"
+	"profile"
+)
+
+// fetchProfiles fetches and symbolizes the profiles specified by s.
+// It will merge all the profiles it is able to retrieve, even if
+// there are some failures. It will return an error if it is unable to
+// fetch any profiles.
+func fetchProfiles(s *source, o *plugin.Options) (*profile.Profile, error) {
+	if err := setTmpDir(o.UI); err != nil {
+		return nil, err
+	}
+
+	p, msrcs, save, err := concurrentGrab(s, o.Fetch, o.Obj, o.UI)
+	if err != nil {
+		return nil, err
+	}
+
+	// Symbolize the merged profile.
+	if err := o.Sym.Symbolize(s.Symbolize, msrcs, p); err != nil {
+		return nil, err
+	}
+	p.RemoveUninteresting()
+
+	// Save a copy of the merged profile if there is at least one remote source.
+	if save {
+		prefix := "pprof."
+		if len(p.Mapping) > 0 && p.Mapping[0].File != "" {
+			prefix += filepath.Base(p.Mapping[0].File) + "."
+		}
+		for _, s := range p.SampleType {
+			prefix += s.Type + "."
+		}
+
+		dir := os.Getenv("PPROF_TMPDIR")
+		tempFile, err := newTempFile(dir, prefix, ".pb.gz")
+		if err == nil {
+			if err = p.Write(tempFile); err == nil {
+				o.UI.PrintErr("Saved profile in ", tempFile.Name())
+			}
+		}
+		if err != nil {
+			o.UI.PrintErr("Could not save profile: ", err)
+		}
+	}
+
+	if err := p.CheckValid(); err != nil {
+		return nil, err
+	}
+
+	return p, nil
+}
+
+// concurrentGrab fetches multiple profiles concurrently
+func concurrentGrab(s *source, fetch plugin.Fetcher, obj plugin.ObjTool, ui plugin.UI) (*profile.Profile, plugin.MappingSources, bool, error) {
+	wg := sync.WaitGroup{}
+	numprofs := len(s.Sources) + len(s.Base)
+	profs := make([]*profile.Profile, numprofs)
+	msrcs := make([]plugin.MappingSources, numprofs)
+	remote := make([]bool, numprofs)
+	errs := make([]error, numprofs)
+	for i, source := range s.Sources {
+		wg.Add(1)
+		go func(i int, src string) {
+			defer wg.Done()
+			profs[i], msrcs[i], remote[i], errs[i] = grabProfile(s, src, 1, fetch, obj, ui)
+		}(i, source)
+	}
+	for i, source := range s.Base {
+		wg.Add(1)
+		go func(i int, src string) {
+			defer wg.Done()
+			profs[i], msrcs[i], remote[i], errs[i] = grabProfile(s, src, -1, fetch, obj, ui)
+		}(i+len(s.Sources), source)
+	}
+	wg.Wait()
+	var save bool
+	var numFailed = 0
+	for i, src := range s.Sources {
+		if errs[i] != nil {
+			ui.PrintErr(src + ": " + errs[i].Error())
+			numFailed++
+		}
+		save = save || remote[i]
+	}
+	for i, src := range s.Base {
+		b := i + len(s.Sources)
+		if errs[b] != nil {
+			ui.PrintErr(src + ": " + errs[b].Error())
+			numFailed++
+		}
+		save = save || remote[b]
+	}
+	if numFailed == numprofs {
+		return nil, nil, false, fmt.Errorf("failed to fetch any profiles")
+	}
+	if numFailed > 0 {
+		ui.PrintErr(fmt.Sprintf("fetched %d profiles out of %d", numprofs-numFailed, numprofs))
+	}
+
+	scaled := make([]*profile.Profile, 0, numprofs)
+	for _, p := range profs {
+		if p != nil {
+			scaled = append(scaled, p)
+		}
+	}
+
+	// Merge profiles.
+	if err := measurement.ScaleProfiles(scaled); err != nil {
+		return nil, nil, false, err
+	}
+
+	p, err := profile.Merge(scaled)
+	if err != nil {
+		return nil, nil, false, err
+	}
+
+	// Combine mapping sources.
+	msrc := make(plugin.MappingSources)
+	for _, ms := range msrcs {
+		for m, s := range ms {
+			msrc[m] = append(msrc[m], s...)
+		}
+	}
+
+	return p, msrc, save, nil
+}
+
+// setTmpDir sets the PPROF_TMPDIR environment variable with a new
+// temp directory, if not already set.
+func setTmpDir(ui plugin.UI) error {
+	if profileDir := os.Getenv("PPROF_TMPDIR"); profileDir != "" {
+		return nil
+	}
+	for _, tmpDir := range []string{os.Getenv("HOME") + "/pprof", "/tmp"} {
+		if err := os.MkdirAll(tmpDir, 0755); err != nil {
+			ui.PrintErr("Could not use temp dir ", tmpDir, ": ", err.Error())
+			continue
+		}
+		os.Setenv("PPROF_TMPDIR", tmpDir)
+		return nil
+	}
+	return fmt.Errorf("failed to identify temp dir")
+}
+
+// grabProfile fetches a profile. Returns the profile, sources for the
+// profile mappings, a bool indicating if the profile was fetched
+// remotely, and an error.
+func grabProfile(s *source, source string, scale float64, fetcher plugin.Fetcher, obj plugin.ObjTool, ui plugin.UI) (p *profile.Profile, msrc plugin.MappingSources, remote bool, err error) {
+	var src string
+	duration, timeout := time.Duration(s.Seconds)*time.Second, time.Duration(s.Timeout)*time.Second
+	if fetcher != nil {
+		p, src, err = fetcher.Fetch(source, duration, timeout)
+		if err != nil {
+			return
+		}
+	}
+	if err != nil || p == nil {
+		// Fetch the profile over HTTP or from a file.
+		p, src, err = fetch(source, duration, timeout, ui)
+		if err != nil {
+			return
+		}
+	}
+
+	if err = p.CheckValid(); err != nil {
+		return
+	}
+
+	// Apply local changes to the profile.
+	p.Scale(scale)
+
+	// Update the binary locations from command line and paths.
+	locateBinaries(p, s, obj, ui)
+
+	// Collect the source URL for all mappings.
+	if src != "" {
+		msrc = collectMappingSources(p, src)
+		remote = true
+	}
+	return
+}
+
+// collectMappingSources saves the mapping sources of a profile.
+func collectMappingSources(p *profile.Profile, source string) plugin.MappingSources {
+	ms := plugin.MappingSources{}
+	for _, m := range p.Mapping {
+		src := struct {
+			Source string
+			Start  uint64
+		}{
+			source, m.Start,
+		}
+		if key := m.BuildID; key != "" {
+			ms[key] = append(ms[key], src)
+		}
+		if key := m.File; key != "" {
+			ms[key] = append(ms[key], src)
+		}
+	}
+	return ms
+}
+
+// locateBinaries searches for binary files listed in the profile and, if found,
+// updates the profile accordingly.
+func locateBinaries(p *profile.Profile, s *source, obj plugin.ObjTool, ui plugin.UI) {
+	// Construct search path to examine
+	searchPath := os.Getenv("PPROF_BINARY_PATH")
+	if searchPath == "" {
+		// Use $HOME/pprof/binaries as default directory for local symbolization binaries
+		searchPath = filepath.Join(os.Getenv("HOME"), "pprof", "binaries")
+	}
+
+mapping:
+	for i, m := range p.Mapping {
+		var baseName string
+		// Replace executable filename/buildID with the overrides from source.
+		// Assumes the executable is the first Mapping entry.
+		if i == 0 {
+			if s.ExecName != "" {
+				m.File = s.ExecName
+			}
+			if s.BuildID != "" {
+				m.BuildID = s.BuildID
+			}
+		}
+		if m.File != "" {
+			baseName = filepath.Base(m.File)
+		}
+
+		for _, path := range filepath.SplitList(searchPath) {
+			var fileNames []string
+			if m.BuildID != "" {
+				fileNames = []string{filepath.Join(path, m.BuildID, baseName)}
+				if matches, err := filepath.Glob(filepath.Join(path, m.BuildID, "*")); err == nil {
+					fileNames = append(fileNames, matches...)
+				}
+			}
+			if baseName != "" {
+				fileNames = append(fileNames, filepath.Join(path, baseName))
+			}
+			for _, name := range fileNames {
+				if f, err := obj.Open(name, m.Start, m.Limit, m.Offset); err == nil {
+					defer f.Close()
+					fileBuildID := f.BuildID()
+					if m.BuildID != "" && m.BuildID != fileBuildID {
+						ui.PrintErr("Ignoring local file " + name + ": build-id mismatch (" + m.BuildID + " != " + fileBuildID + ")")
+					} else {
+						m.File = name
+						continue mapping
+					}
+				}
+			}
+		}
+	}
+}
+
+// fetch fetches a profile from source, within the timeout specified,
+// producing messages through the ui. It returns the profile and the
+// url of the actual source of the profile for remote profiles.
+func fetch(source string, duration, timeout time.Duration, ui plugin.UI) (p *profile.Profile, src string, err error) {
+	var f io.ReadCloser
+
+	if sourceURL, timeout := adjustURL(source, duration, timeout); sourceURL != "" {
+		ui.Print("Fetching profile over HTTP from " + sourceURL)
+		if duration > 0 {
+			ui.Print(fmt.Sprintf("Please wait... (%v)", duration))
+		}
+		f, err = fetchURL(sourceURL, timeout)
+		src = sourceURL
+	} else {
+		f, err = os.Open(source)
+	}
+	if err == nil {
+		defer f.Close()
+		p, err = profile.Parse(f)
+	}
+	return
+}
+
+// fetchURL fetches a profile from a URL using HTTP.
+func fetchURL(source string, timeout time.Duration) (io.ReadCloser, error) {
+	resp, err := httpGet(source, timeout)
+	if err != nil {
+		return nil, fmt.Errorf("http fetch %s: %v", source, err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("server response: %s", resp.Status)
+	}
+
+	return resp.Body, nil
+}
+
+// adjustURL validates if a profile source is a URL and returns an
+// cleaned up URL and the timeout to use for retrieval over HTTP.
+// If the source cannot be recognized as a URL it returns an empty string.
+func adjustURL(source string, duration, timeout time.Duration) (string, time.Duration) {
+	u, err := url.Parse(source)
+	if err != nil || (u.Host == "" && u.Scheme != "" && u.Scheme != "file") {
+		// Try adding http:// to catch sources of the form hostname:port/path.
+		// url.Parse treats "hostname" as the scheme.
+		u, err = url.Parse("http://" + source)
+	}
+	if err != nil || u.Host == "" {
+		return "", 0
+	}
+
+	// Apply duration/timeout overrides to URL.
+	values := u.Query()
+	if duration > 0 {
+		values.Set("seconds", fmt.Sprint(int(duration.Seconds())))
+	} else {
+		if urlSeconds := values.Get("seconds"); urlSeconds != "" {
+			if us, err := strconv.ParseInt(urlSeconds, 10, 32); err == nil {
+				duration = time.Duration(us) * time.Second
+			}
+		}
+	}
+	if timeout <= 0 {
+		if duration > 0 {
+			timeout = duration + duration/2
+		} else {
+			timeout = 60 * time.Second
+		}
+	}
+	u.RawQuery = values.Encode()
+	return u.String(), timeout
+}
+
+// httpGet is a wrapper around http.Get; it is defined as a variable
+// so it can be redefined during for testing.
+var httpGet = func(url string, timeout time.Duration) (*http.Response, error) {
+	client := &http.Client{
+		Transport: &http.Transport{
+			ResponseHeaderTimeout: timeout + 5*time.Second,
+		},
+	}
+	return client.Get(url)
+}

src/internal/driver/fetch_test.go

+// 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.
+
+package driver
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"testing"
+	"time"
+
+	"internal/plugin"
+	"internal/proftest"
+	"profile"
+)
+
+func TestSymbolizationPath(t *testing.T) {
+	// Save environment variables to restore after test
+	saveHome := os.Getenv("HOME")
+	savePath := os.Getenv("PPROF_BINARY_PATH")
+
+	tempdir, err := ioutil.TempDir("", "home")
+	if err != nil {
+		t.Fatal("creating temp dir: ", err)
+	}
+	defer os.RemoveAll(tempdir)
+	os.MkdirAll(filepath.Join(tempdir, "pprof", "binaries", "abcde10001"), 0700)
+	os.Create(filepath.Join(tempdir, "pprof", "binaries", "abcde10001", "binary"))
+
+	obj := testObj{tempdir}
+	os.Setenv("HOME", tempdir)
+	for _, tc := range []struct {
+		env, file, buildID, want string
+		msgCount                 int
+	}{
+		{"", "/usr/bin/binary", "", "/usr/bin/binary", 0},
+		{"", "/usr/bin/binary", "fedcb10000", "/usr/bin/binary", 0},
+		{"", "/prod/path/binary", "abcde10001", filepath.Join(tempdir, "pprof/binaries/abcde10001/binary"), 0},
+		{"/alternate/architecture", "/usr/bin/binary", "", "/alternate/architecture/binary", 0},
+		{"/alternate/architecture", "/usr/bin/binary", "abcde10001", "/alternate/architecture/binary", 0},
+		{"/nowhere:/alternate/architecture", "/usr/bin/binary", "fedcb10000", "/usr/bin/binary", 1},
+		{"/nowhere:/alternate/architecture", "/usr/bin/binary", "abcde10002", "/usr/bin/binary", 1},
+	} {
+		os.Setenv("PPROF_BINARY_PATH", tc.env)
+		p := &profile.Profile{
+			Mapping: []*profile.Mapping{
+				{
+					File:    tc.file,
+					BuildID: tc.buildID,
+				},
+			},
+		}
+		s := &source{}
+		locateBinaries(p, s, obj, &proftest.TestUI{t, tc.msgCount})
+		if file := p.Mapping[0].File; file != tc.want {
+			t.Errorf("%s:%s:%s, want %s, got %s", tc.env, tc.file, tc.buildID, tc.want, file)
+		}
+	}
+	os.Setenv("HOME", saveHome)
+	os.Setenv("PPROF_BINARY_PATH", savePath)
+}
+
+type testObj struct {
+	home string
+}
+
+func (o testObj) Open(file string, start, limit, offset uint64) (plugin.ObjFile, error) {
+	switch file {
+	case "/alternate/architecture/binary":
+		return testFile{file, "abcde10001"}, nil
+	case "/usr/bin/binary":
+		return testFile{file, "fedcb10000"}, nil
+	case filepath.Join(o.home, "pprof/binaries/abcde10001/binary"):
+		return testFile{file, "abcde10001"}, nil
+	}
+	return nil, fmt.Errorf("not found: %s", file)
+}
+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 }
+
+type testFile struct{ name, buildID string }
+
+func (f testFile) Name() string                                               { return f.name }
+func (testFile) Base() uint64                                                 { return 0 }
+func (f testFile) BuildID() string                                            { return f.buildID }
+func (testFile) SourceLine(addr uint64) ([]plugin.Frame, error)               { return nil, nil }
+func (testFile) Symbols(r *regexp.Regexp, addr uint64) ([]*plugin.Sym, error) { return nil, nil }
+func (testFile) Close() error                                                 { return nil }
+
+func TestFetch(t *testing.T) {
+	const path = "testdata/"
+
+	// Intercept http.Get calls from HTTPFetcher.
+	httpGet = stubHTTPGet
+
+	for _, source := range [][2]string{
+		{path + "go.crc32.cpu", "go.crc32.cpu"},
+		{"http://localhost/profile?file=cppbench.cpu", "cppbench.cpu"},
+	} {
+		p, _, err := fetch(source[0], 0, 10*time.Second, &proftest.TestUI{t, 0})
+		if err != nil {
+			t.Fatalf("%s: %s", source[0], err)
+		}
+		if len(p.Sample) == 0 {
+			t.Errorf("want non-zero samples")
+		}
+	}
+}
+
+// stubHTTPGet intercepts a call to http.Get and rewrites it to use
+// "file://" to get the profile directly from a file.
+func stubHTTPGet(source string, _ time.Duration) (*http.Response, error) {
+	url, err := url.Parse(source)
+	if err != nil {
+		return nil, err
+	}
+
+	values := url.Query()
+	file := values.Get("file")
+
+	if file == "" {
+		return nil, fmt.Errorf("want .../file?profile, got %s", source)
+	}
+
+	t := &http.Transport{}
+	t.RegisterProtocol("file", http.NewFileTransport(http.Dir("testdata/")))
+
+	c := &http.Client{Transport: t}
+	return c.Get("file:///" + file)
+}

src/internal/driver/interactive.go

+// 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.
+
+package driver
+
+import (
+	"fmt"
+	"io"
+	"sort"
+	"strconv"
+	"strings"
+
+	"internal/plugin"
+	"internal/report"
+	"profile"
+)
+
+// interactive starts a shell to read pprof commands.
+func interactive(p *profile.Profile, o *plugin.Options) error {
+	// Enter command processing loop.
+	o.UI.SetAutoComplete(newCompleter(functionNames(p)))
+	pprofVariables.set("compact_labels", "true")
+
+	// Do not wait for the visualizer to complete, to allow multiple
+	// graphs to be visualized simultaneously.
+	waitForVisualizer = false
+	shortcuts := profileShortcuts(p)
+
+	greetings(p, o.UI)
+	for {
+		input, err := o.UI.ReadLine(pprofPrompt(p))
+		if err != nil {
+			if err != io.EOF {
+				return err
+			}
+			if input == "" {
+				return nil
+			}
+		}
+
+		for _, input := range shortcuts.expand(input) {
+			// Process assignments of the form variable=value
+			if s := strings.SplitN(input, "=", 2); len(s) > 0 {
+				name := strings.TrimSpace(s[0])
+
+				if v := pprofVariables[name]; v != nil {
+					var value string
+					if len(s) == 2 {
+						value = strings.TrimSpace(s[1])
+					}
+					if err := pprofVariables.set(name, value); err != nil {
+						o.UI.PrintErr(err)
+					}
+					continue
+				}
+			}
+
+			tokens := strings.Fields(input)
+			if len(tokens) == 0 {
+				continue
+			}
+
+			switch tokens[0] {
+			case "exit", "quit":
+				return nil
+			case "help":
+				commandHelp(strings.Join(tokens[1:], " "), o.UI)
+				continue
+			}
+
+			args, vars, err := parseCommandLine(tokens)
+			if err == nil {
+				err = generateReportWrapper(p, args, vars, o)
+			}
+
+			if err != nil {
+				o.UI.PrintErr(err)
+			}
+		}
+	}
+}
+
+var generateReportWrapper = generateReport // For testing purposes.
+
+// greetings prints a brief welcome and some overall profile
+// information before accepting interactive commands.
+func greetings(p *profile.Profile, ui plugin.UI) {
+	ropt, err := reportOptions(p, pprofVariables)
+	if err == nil {
+		ui.Print(strings.Join(report.ProfileLabels(report.New(p, ropt)), "\n"))
+	}
+	ui.Print("Entering interactive mode (type \"help\" for commands)")
+}
+
+// shortcuts represents composite commands that expand into a sequence
+// of other commands.
+type shortcuts map[string][]string
+
+func (a shortcuts) expand(input string) []string {
+	if a != nil {
+		if r, ok := a[input]; ok {
+			return r
+		}
+	}
+	return []string{input}
+}
+
+var pprofShortcuts = shortcuts{
+	":": []string{"focus=", "ignore=", "hide=", "tagfocus=", "tagignore="},
+}
+
+// profileShortcuts creates macros for convenience and backward compatibility.
+func profileShortcuts(p *profile.Profile) shortcuts {
+	s := pprofShortcuts
+	// Add shortcuts for sample types
+	for _, st := range p.SampleType {
+		command := fmt.Sprintf("sample_index=%s", st.Type)
+		s[st.Type] = []string{command}
+		s["total_"+st.Type] = []string{"mean=0", command}
+		s["mean_"+st.Type] = []string{"mean=1", command}
+	}
+	return s
+}
+
+// pprofPrompt returns the prompt displayed to accept commands.
+// hides some default values to reduce clutter.
+func pprofPrompt(p *profile.Profile) string {
+	var args []string
+	for n, o := range pprofVariables {
+		v := o.stringValue()
+		if v == "" {
+			continue
+		}
+		// Do not show some default values.
+		switch {
+		case n == "unit" && v == "minimum":
+			continue
+		case n == "divide_by" && v == "1":
+			continue
+		case n == "nodecount" && v == "-1":
+			continue
+		case n == "sample_index":
+			index, err := locateSampleIndex(p, v)
+			if err != nil {
+				v = "ERROR: " + err.Error()
+			} else {
+				v = fmt.Sprintf("%s (%d)", p.SampleType[index].Type, index)
+			}
+		case n == "trim" || n == "compact_labels":
+			if o.boolValue() == true {
+				continue
+			}
+		case o.kind == boolKind:
+			if o.boolValue() == false {
+				continue
+			}
+		}
+		args = append(args, fmt.Sprintf("  %-25s : %s", n, v))
+	}
+	sort.Strings(args)
+	return "Options:\n" + strings.Join(args, "\n") + "\nPPROF>"
+}
+
+// parseCommandLine parses a command and returns the pprof command to
+// execute and a set of variables for the report.
+func parseCommandLine(input []string) ([]string, variables, error) {
+	cmd, args := input[:1], input[1:]
+	name := cmd[0]
+
+	c := pprofCommands[cmd[0]]
+	if c == nil {
+		return nil, nil, fmt.Errorf("Unrecognized command: %q", name)
+	}
+
+	if c.hasParam {
+		if len(args) == 0 {
+			return nil, nil, fmt.Errorf("command %s requires an argument", name)
+		}
+		cmd = append(cmd, args[0])
+		args = args[1:]
+	}
+
+	// Copy the variables as options set in the command line are not persistent.
+	vcopy := pprofVariables.makeCopy()
+
+	var focus, ignore string
+	for i := 0; i < len(args); i++ {
+		t := args[i]
+		if _, err := strconv.ParseInt(t, 10, 32); err == nil {
+			vcopy.set("nodecount", t)
+			continue
+		}
+		switch t[0] {
+		case '>':
+			outputFile := t[1:]
+			if outputFile == "" {
+				i++
+				if i >= len(args) {
+					return nil, nil, fmt.Errorf("Unexpected end of line after >")
+				}
+				outputFile = args[i]
+			}
+			vcopy.set("output", outputFile)
+		case '-':
+			if t == "--cum" || t == "-cum" {
+				vcopy.set("cum", "t")
+				continue
+			}
+			ignore = catRegex(ignore, t[1:])
+		default:
+			focus = catRegex(focus, t)
+		}
+	}
+
+	if name == "tags" {
+		updateFocusIgnore(vcopy, "tag", focus, ignore)
+	} else {
+		updateFocusIgnore(vcopy, "", focus, ignore)
+	}
+
+	if vcopy["nodecount"].intValue() == -1 && (name == "text" || name == "top") {
+		vcopy.set("nodecount", "10")
+	}
+
+	return cmd, vcopy, nil
+}
+
+func updateFocusIgnore(v variables, prefix, f, i string) {
+	if f != "" {
+		focus := prefix + "focus"
+		v.set(focus, catRegex(v[focus].value, f))
+	}
+
+	if i != "" {
+		ignore := prefix + "ignore"
+		v.set(ignore, catRegex(v[ignore].value, i))
+	}
+}
+
+func catRegex(a, b string) string {
+	if a != "" && b != "" {
+		return a + "|" + b
+	}
+	return a + b
+}
+
+// commandHelp displays help and usage information for all Commands
+// and Variables or a specific Command or Variable.
+func commandHelp(args string, ui plugin.UI) {
+	if args == "" {
+		help := usage(false)
+		help = help + `
+  :   Clear focus/ignore/hide/tagfocus/tagignore
+
+  type "help <cmd|option>" for more information
+`
+
+		ui.Print(help)
+		return
+	}
+
+	if c := pprofCommands[args]; c != nil {
+		ui.Print(c.help(args))
+		return
+	}
+
+	if v := pprofVariables[args]; v != nil {
+		ui.Print(v.help + "\n")
+		return
+	}
+
+	ui.PrintErr("Unknown command: " + args)
+}
+
+// newCompleter creates an autocompletion function for a set of commands.
+func newCompleter(fns []string) func(string) string {
+	return func(line string) string {
+		v := pprofVariables
+		switch tokens := strings.Fields(line); len(tokens) {
+		case 0:
+			// Nothing to complete
+		case 1:
+			// Single token -- complete command name
+			if match := matchVariableOrCommand(v, tokens[0]); match != "" {
+				return match
+			}
+		case 2:
+			if tokens[0] == "help" {
+				if match := matchVariableOrCommand(v, tokens[1]); match != "" {
+					return tokens[0] + " " + match
+				}
+				return line
+			}
+			fallthrough
+		default:
+			// Multiple tokens -- complete using functions, except for tags
+			if cmd := pprofCommands[tokens[0]]; cmd != nil && tokens[0] != "tags" {
+				lastTokenIdx := len(tokens) - 1
+				lastToken := tokens[lastTokenIdx]
+				if strings.HasPrefix(lastToken, "-") {
+					lastToken = "-" + functionCompleter(lastToken[1:], fns)
+				} else {
+					lastToken = functionCompleter(lastToken, fns)
+				}
+				return strings.Join(append(tokens[:lastTokenIdx], lastToken), " ")
+			}
+		}
+		return line
+	}
+}
+
+// matchCommand attempts to match a string token to the prefix of a Command.
+func matchVariableOrCommand(v variables, token string) string {
+	token = strings.ToLower(token)
+	found := ""
+	for cmd := range pprofCommands {
+		if strings.HasPrefix(cmd, token) {
+			if found != "" {
+				return ""
+			}
+			found = cmd
+		}
+	}
+	for variable := range v {
+		if strings.HasPrefix(variable, token) {
+			if found != "" {
+				return ""
+			}
+			found = variable
+		}
+	}
+	return found
+}
+
+// functionCompleter replaces provided substring with a function
+// name retrieved from a profile if a single match exists. Otherwise,
+// it returns unchanged substring. It defaults to no-op if the profile
+// is not specified.
+func functionCompleter(substring string, fns []string) string {
+	found := ""
+	for _, fName := range fns {
+		if strings.Contains(fName, substring) {
+			if found != "" {
+				return substring
+			}
+			found = fName
+		}
+	}
+	if found != "" {
+		return found
+	}
+	return substring
+}
+
+func functionNames(p *profile.Profile) []string {
+	var fns []string
+	for _, fn := range p.Function {
+		fns = append(fns, fn.Name)
+	}
+	return fns
+}

src/internal/driver/interactive_test.go

+// 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.
+
+package driver
+
+import (
+	"fmt"
+	"io"
+	"math/rand"
+	"strings"
+	"testing"
+
+	"internal/plugin"
+	"profile"
+	"internal/report"
+)
+
+func TestShell(t *testing.T) {
+	p := &profile.Profile{}
+	generateReportWrapper = checkValue
+	defer func() { generateReportWrapper = generateReport }()
+
+	// Use test commands and variables to exercise interactive processing
+	var savedCommands commands
+	savedCommands, pprofCommands = pprofCommands, testCommands
+	defer func() { pprofCommands = savedCommands }()
+
+	savedVariables := pprofVariables
+	defer func() { pprofVariables = savedVariables }()
+
+	// Random interleave of independent scripts
+	pprofVariables = testVariables(savedVariables)
+	o := setDefaults(nil)
+	o.UI = newUI(t, interleave(script, 0))
+	if err := interactive(p, o); err != nil {
+		t.Error("first attempt:", err)
+	}
+	// Random interleave of independent scripts
+	pprofVariables = testVariables(savedVariables)
+	o.UI = newUI(t, interleave(script, 1))
+	if err := interactive(p, o); err != nil {
+		t.Error("second attempt:", err)
+	}
+
+	// Random interleave of independent scripts with shortcuts
+	pprofVariables = testVariables(savedVariables)
+	var scScript []string
+	pprofShortcuts, scScript = makeShortcuts(interleave(script, 2), 1)
+	o.UI = newUI(t, scScript)
+	if err := interactive(p, o); err != nil {
+		t.Error("first shortcut attempt:", err)
+	}
+
+	// Random interleave of independent scripts with shortcuts
+	pprofVariables = testVariables(savedVariables)
+	pprofShortcuts, scScript = makeShortcuts(interleave(script, 1), 2)
+	o.UI = newUI(t, scScript)
+	if err := interactive(p, o); err != nil {
+		t.Error("second shortcut attempt:", err)
+	}
+
+	// Verify propagation of IO errors
+	pprofVariables = testVariables(savedVariables)
+	o.UI = newUI(t, []string{"**error**"})
+	if err := interactive(p, o); err == nil {
+		t.Error("expected IO error, got nil")
+	}
+
+}
+
+var testCommands = commands{
+	"check": &command{report.Raw, nil, true, "", ""},
+}
+
+func testVariables(base variables) variables {
+	v := base.makeCopy()
+
+	v["b"] = &variable{boolKind, "f", "", ""}
+	v["bb"] = &variable{boolKind, "f", "", ""}
+	v["i"] = &variable{intKind, "0", "", ""}
+	v["ii"] = &variable{intKind, "0", "", ""}
+	v["f"] = &variable{floatKind, "0", "", ""}
+	v["ff"] = &variable{floatKind, "0", "", ""}
+	v["s"] = &variable{stringKind, "", "", ""}
+	v["ss"] = &variable{stringKind, "", "", ""}
+
+	v["ta"] = &variable{boolKind, "f", "radio", ""}
+	v["tb"] = &variable{boolKind, "f", "radio", ""}
+	v["tc"] = &variable{boolKind, "t", "radio", ""}
+
+	return v
+}
+
+// script contains sequences of commands to be executed for testing. Commands
+// are split by semicolon and interleaved randomly, so they must be
+// independent from each other.
+var script = []string{
+	"bb=true;bb=false;check bb=false;bb=yes;check bb=true",
+	"b=1;check b=true;b=n;check b=false",
+	"i=-1;i=-2;check i=-2;i=999999;check i=999999",
+	"check ii=0;ii=-1;check ii=-1;ii=100;check ii=100",
+	"f=-1;f=-2.5;check f=-2.5;f=0.0001;check f=0.0001",
+	"check ff=0;ff=-1.01;check ff=-1.01;ff=100;check ff=100",
+	"s=one;s=two;check s=two",
+	"ss=tree;check ss=tree;ss=;check ss;ss=forest;check ss=forest",
+	"ta=true;check ta=true;check tb=false;check tc=false;tb=1;check tb=true;check ta=false;check tc=false;tc=yes;check tb=false;check ta=false;check tc=true",
+}
+
+func makeShortcuts(input []string, seed int) (shortcuts, []string) {
+	rand.Seed(int64(seed))
+
+	s := shortcuts{}
+	var output, chunk []string
+	for _, l := range input {
+		chunk = append(chunk, l)
+		switch rand.Intn(3) {
+		case 0:
+			// Create a macro for commands in 'chunk'.
+			macro := fmt.Sprintf("alias%d", len(s))
+			s[macro] = chunk
+			output = append(output, macro)
+			chunk = nil
+		case 1:
+			// Append commands in 'chunk' by themselves.
+			output = append(output, chunk...)
+			chunk = nil
+		case 2:
+			// Accumulate commands into 'chunk'
+		}
+	}
+	output = append(output, chunk...)
+	return s, output
+}
+
+func newUI(t *testing.T, input []string) plugin.UI {
+	return &testUI{
+		t:     t,
+		input: input,
+	}
+}
+
+type testUI struct {
+	t     *testing.T
+	input []string
+	index int
+}
+
+func (ui *testUI) ReadLine(_ string) (string, error) {
+	if ui.index >= len(ui.input) {
+		return "", io.EOF
+	}
+	input := ui.input[ui.index]
+	if input == "**error**" {
+		return "", fmt.Errorf("Error: %s", input)
+	}
+	ui.index++
+	return input, nil
+}
+
+func (ui *testUI) Print(args ...interface{}) {
+}
+
+func (ui *testUI) PrintErr(args ...interface{}) {
+	output := fmt.Sprint(args)
+	if output != "" {
+		ui.t.Error(output)
+	}
+}
+
+func (ui *testUI) IsTerminal() bool {
+	return false
+}
+
+func (ui *testUI) SetAutoComplete(func(string) string) {
+}
+
+func checkValue(p *profile.Profile, cmd []string, vars variables, o *plugin.Options) error {
+	if len(cmd) != 2 {
+		return fmt.Errorf("expected len(cmd)==2, got %v", cmd)
+	}
+
+	input := cmd[1]
+	args := strings.SplitN(input, "=", 2)
+	if len(args) == 0 {
+		return fmt.Errorf("unexpected empty input")
+	}
+	name, value := args[0], ""
+	if len(args) == 2 {
+		value = args[1]
+	}
+
+	gotv := vars[name]
+	if gotv == nil {
+		return fmt.Errorf("Could not find variable named %s", name)
+	}
+
+	if got := gotv.stringValue(); got != value {
+		return fmt.Errorf("Variable %s, want %s, got %s", name, value, got)
+	}
+	return nil
+}
+
+func interleave(input []string, seed int) []string {
+	var inputs [][]string
+	for _, s := range input {
+		inputs = append(inputs, strings.Split(s, ";"))
+	}
+	rand.Seed(int64(seed))
+	var output []string
+	for len(inputs) > 0 {
+		next := rand.Intn(len(inputs))
+		output = append(output, inputs[next][0])
+		if tail := inputs[next][1:]; len(tail) > 0 {
+			inputs[next] = tail
+		} else {
+			inputs = append(inputs[:next], inputs[next+1:]...)
+		}
+	}
+	return output
+}
+
+func TestInteractiveCommands(t *testing.T) {
+	type interactiveTestcase struct {
+		input string
+		want  map[string]string
+	}
+
+	testcases := []interactiveTestcase{
+		{
+			"top 10 --cum focus1 -ignore focus2",
+			map[string]string{
+				"functions": "true",
+				"nodecount": "10",
+				"cum":       "true",
+				"focus":     "focus1|focus2",
+				"ignore":    "ignore",
+			},
+		},
+		{
+			"dot",
+			map[string]string{
+				"functions": "true",
+				"nodecount": "80",
+				"cum":       "false",
+			},
+		},
+		{
+			"tags   -ignore1 -ignore2 focus1 >out",
+			map[string]string{
+				"functions": "true",
+				"nodecount": "80",
+				"cum":       "false",
+				"output":    "out",
+				"tagfocus":  "focus1",
+				"tagignore": "ignore1|ignore2",
+			},
+		},
+		{"weblist  find -test",
+			map[string]string{
+				"functions":        "false",
+				"addressnoinlines": "true",
+				"nodecount":        "0",
+				"cum":              "false",
+				"flat":             "true",
+				"ignore":           "test",
+			},
+		},
+		{
+			"callgrind   fun -ignore  >out",
+			map[string]string{
+				"functions": "false",
+				"lines":     "true",
+				"nodecount": "0",
+				"cum":       "false",
+				"flat":      "true",
+				"output":    "out",
+			},
+		},
+	}
+
+	for _, tc := range testcases {
+		cmd, vars, err := parseCommandLine(strings.Fields(tc.input))
+		vars = applyCommandOverrides(cmd, vars)
+		if err != nil {
+			t.Errorf("failed on %q: %v", tc.input, err)
+		}
+
+		for n, want := range tc.want {
+			if got := vars[n].stringValue(); got != want {
+				t.Errorf("failed on %q, cmd=%q, %s got %s, want %s", tc.input, cmd, n, got, want)
+			}
+		}
+	}
+}

src/internal/driver/options.go

+// 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.
+
+package driver
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"internal/binutils"
+	"internal/plugin"
+	"internal/symbolizer"
+)
+
+// setDefaults returns a new plugin.Options with zero fields sets to
+// sensible defaults.
+func setDefaults(o *plugin.Options) *plugin.Options {
+	d := &plugin.Options{}
+	if o != nil {
+		*d = *o
+	}
+	if d.Writer == nil {
+		d.Writer = oswriter{}
+	}
+	if d.Flagset == nil {
+		d.Flagset = goFlags{}
+	}
+	if d.Obj == nil {
+		d.Obj = &binutils.Binutils{}
+	}
+	if d.UI == nil {
+		d.UI = &stdUI{r: bufio.NewReader(os.Stdin)}
+	}
+	if d.Sym == nil {
+		d.Sym = &symbolizer.Symbolizer{d.Obj, d.UI}
+	}
+	return d
+}
+
+// goFlags returns a flagset implementation based on the standard flag
+// package from the Go distribution. It implements the plugin.FlagSet
+// interface.
+type goFlags struct{}
+
+func (goFlags) Bool(o string, d bool, c string) *bool {
+	return flag.Bool(o, d, c)
+}
+
+func (goFlags) Int(o string, d int, c string) *int {
+	return flag.Int(o, d, c)
+}
+
+func (goFlags) Float64(o string, d float64, c string) *float64 {
+	return flag.Float64(o, d, c)
+}
+
+func (goFlags) String(o, d, c string) *string {
+	return flag.String(o, d, c)
+}
+
+func (goFlags) BoolVar(b *bool, o string, d bool, c string) {
+	flag.BoolVar(b, o, d, c)
+}
+
+func (goFlags) IntVar(i *int, o string, d int, c string) {
+	flag.IntVar(i, o, d, c)
+}
+
+func (goFlags) Float64Var(f *float64, o string, d float64, c string) {
+	flag.Float64Var(f, o, d, c)
+}
+
+func (goFlags) StringVar(s *string, o, d, c string) {
+	flag.StringVar(s, o, d, c)
+}
+
+func (goFlags) StringList(o, d, c string) *[]*string {
+	return &[]*string{flag.String(o, d, c)}
+}
+
+func (goFlags) ExtraUsage() string {
+	return ""
+}
+
+func (goFlags) Parse(usage func()) []string {
+	flag.Usage = usage
+	flag.Parse()
+	args := flag.Args()
+	if len(args) == 0 {
+		usage()
+	}
+	return args
+}
+
+type stdUI struct {
+	r *bufio.Reader
+}
+
+func (ui *stdUI) ReadLine(prompt string) (string, error) {
+	os.Stdout.WriteString(prompt)
+	return ui.r.ReadString('\n')
+}
+
+func (ui *stdUI) Print(args ...interface{}) {
+	ui.fprint(os.Stderr, args)
+}
+
+func (ui *stdUI) PrintErr(args ...interface{}) {
+	ui.fprint(os.Stderr, args)
+}
+
+func (ui *stdUI) IsTerminal() bool {
+	return false
+}
+
+func (ui *stdUI) SetAutoComplete(func(string) string) {
+}
+
+func (ui *stdUI) fprint(f *os.File, args []interface{}) {
+	text := fmt.Sprint(args...)
+	if !strings.HasSuffix(text, "\n") {
+		text += "\n"
+	}
+	f.WriteString(text)
+}
+
+// oswriter implements the Writer interface using a regular file.
+type oswriter struct{}
+
+func (oswriter) Open(name string) (io.WriteCloser, error) {
+	f, err := os.Create(name)
+	return f, err
+}

src/internal/driver/tempfile.go

+// 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.
+
+package driver
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+)
+
+// newTempFile returns an unused filename for output files.
+func newTempFile(dir, prefix, suffix string) (*os.File, error) {
+	for index := 1; index < 10000; index++ {
+		path := filepath.Join(dir, fmt.Sprintf("%s%03d%s", prefix, index, suffix))
+		if _, err := os.Stat(path); err != nil {
+			return os.Create(path)
+		}
+	}
+	// Give up
+	return nil, fmt.Errorf("could not create file of the form %s%03d%s", prefix, 1, suffix)
+}
+
+var tempFiles []string
+var tempFilesMu = sync.Mutex{}
+
+// deferDeleteTempFile marks a file to be deleted by next call to Cleanup()
+func deferDeleteTempFile(path string) {
+	tempFilesMu.Lock()
+	tempFiles = append(tempFiles, path)
+	tempFilesMu.Unlock()
+}
+
+// cleanupTempFiles removes any temporary files selected for deferred cleaning.
+func cleanupTempFiles() {
+	tempFilesMu.Lock()
+	for _, f := range tempFiles {
+		os.Remove(f)
+	}
+	tempFiles = nil
+	tempFilesMu.Unlock()
+}

src/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>

src/internal/driver/testdata/file1000.src

+line1
+line2
+line3
+line4
+line5
+line6
+line7
+line8
+line9
+line0
+line1
+line2
+line3
+line4
+line5
+		
+

src/internal/driver/testdata/file2000.src

+line1
+line2
+line3
+line4
+line5
+line6
+line7
+line8
+line9
+line0
+line1
+line2
+line3
+line4
+line5
+		
+

src/internal/driver/testdata/file3000.src

+line1
+line2
+line3
+line4
+line5
+line6
+line7
+line8
+line9
+line0
+line1
+line2
+line3
+line4
+line5
+		
+

src/internal/driver/testdata/pprof.contention.cum.files.dot

+digraph "." {
+node [style=filled fillcolor="#f8f8f8"]
+subgraph cluster_L { "Build ID: buildid-contention" [shape=box fontsize=16 label="Build ID: buildid-contention\lComment #1\lComment #2\lType: delay\lShowing nodes accounting for 149.50ms, 100% of 149.50ms total\l"] }
+N1 [label="file3000.src\n32.77ms (21.92%)\nof 149.50ms (100%)" fontsize=20 shape=box tooltip="testdata/file3000.src (149.50ms)" color="#b20000" fillcolor="#edd5d5"]
+N2 [label="file1000.src\n51.20ms (34.25%)" fontsize=23 shape=box tooltip="testdata/file1000.src (51.20ms)" color="#b23100" fillcolor="#eddbd5"]
+N3 [label="file2000.src\n65.54ms (43.84%)\nof 75.78ms (50.68%)" fontsize=24 shape=box tooltip="testdata/file2000.src (75.78ms)" color="#b22000" fillcolor="#edd9d5"]
+N1 -> N3 [label=" 75.78ms" weight=51 penwidth=3 color="#b22000" tooltip="testdata/file3000.src -> testdata/file2000.src (75.78ms)" labeltooltip="testdata/file3000.src -> testdata/file2000.src (75.78ms)"]
+N1 -> N2 [label=" 40.96ms" weight=28 penwidth=2 color="#b23900" tooltip="testdata/file3000.src -> testdata/file1000.src (40.96ms)" labeltooltip="testdata/file3000.src -> testdata/file1000.src (40.96ms)"]
+N3 -> N2 [label=" 10.24ms" weight=7 color="#b29775" tooltip="testdata/file2000.src -> testdata/file1000.src (10.24ms)" labeltooltip="testdata/file2000.src -> testdata/file1000.src (10.24ms)"]
+}

src/internal/driver/testdata/pprof.contention.flat.addresses.dot.focus.ignore

+digraph "." {
+node [style=filled fillcolor="#f8f8f8"]
+subgraph cluster_L { "Build ID: buildid-contention" [shape=box fontsize=16 label="Build ID: buildid-contention\lComment #1\lComment #2\lType: delay\lShowing nodes accounting for 40.96ms, 27.40% of 149.50ms total\l"] }
+N1 [label="0000000000001000\nline1000\nfile1000.src:1\n40.96ms (27.40%)" fontsize=24 shape=box tooltip="0000000000001000 line1000 testdata/file1000.src:1 (40.96ms)" color="#b23900" fillcolor="#edddd5"]
+N2 [label="0000000000003001\nline3000\nfile3000.src:5\n0 of 40.96ms (27.40%)" fontsize=8 shape=box tooltip="0000000000003001 line3000 testdata/file3000.src:5 (40.96ms)" color="#b23900" fillcolor="#edddd5"]
+N3 [label="0000000000003001\nline3001\nfile3000.src:3\n0 of 40.96ms (27.40%)" fontsize=8 shape=box tooltip="0000000000003001 line3001 testdata/file3000.src:3 (40.96ms)" color="#b23900" fillcolor="#edddd5"]
+N2 -> N3 [label=" 40.96ms\n (inline)" weight=28 penwidth=2 color="#b23900" tooltip="0000000000003001 line3000 testdata/file3000.src:5 -> 0000000000003001 line3001 testdata/file3000.src:3 (40.96ms)" labeltooltip="0000000000003001 line3000 testdata/file3000.src:5 -> 0000000000003001 line3001 testdata/file3000.src:3 (40.96ms)"]
+N3 -> N1 [label=" 40.96ms" weight=28 penwidth=2 color="#b23900" tooltip="0000000000003001 line3001 testdata/file3000.src:3 -> 0000000000001000 line1000 testdata/file1000.src:1 (40.96ms)" labeltooltip="0000000000003001 line3001 testdata/file3000.src:3 -> 0000000000001000 line1000 testdata/file1000.src:1 (40.96ms)"]
+}

src/internal/driver/testdata/pprof.cpu.callgrind

+events: cpu(ms)
+fl=(1) testdata/file1000.src
+fn=(1) line1000
+1 1100
+
+fl=(2) testdata/file2000.src
+fn=(2) line2001
+9 10
+cfl=(1)
+cfn=(1)
+calls=0 1
+9 1000
+
+fl=(3) testdata/file3000.src
+fn=(3) line3002
+2 10
+cfl=(2)
+cfn=(4) line2000
+calls=0 4
+2 1000
+
+fl=(2)
+fn=(4)
+4 0
+cfl=(2)
+cfn=(2)
+calls=0 9
+4 1010
+
+fl=(3)
+fn=(5) line3000
+6 0
+cfl=(3)
+cfn=(6) line3001
+calls=0 5
+6 1010
+
+fl=(3)
+fn=(5)
+7 0
+cfl=(3)
+cfn=(3)
+calls=0 5
+7 10
+
+fl=(3)
+fn=(5)
+9 0
+cfl=(3)
+cfn=(6)
+calls=0 8
+9 100
+
+fl=(3)
+fn=(6)
+5 0
+cfl=(3)
+cfn=(3)
+calls=0 2
+5 1010
+
+fl=(3)
+fn=(6)
+8 0
+cfl=(1)
+cfn=(1)
+calls=0 1
+8 100
+
+fl=(3)
+fn=(3)
+5 0
+cfl=(2)
+cfn=(4)
+calls=0 4
+5 10
+

src/internal/driver/testdata/pprof.cpu.cum.lines.text.hide

+Showing nodes accounting for 1.11s, 99.11% of 1.12s total
+      flat  flat%   sum%        cum   cum%
+     1.10s 98.21% 98.21%      1.10s 98.21%  line1000 testdata/file1000.src:1
+         0     0% 98.21%      1.01s 90.18%  line2000 testdata/file2000.src:4
+     0.01s  0.89% 99.11%      1.01s 90.18%  line2001 testdata/file2000.src:9 (inline)

src/internal/driver/testdata/pprof.cpu.cum.lines.text.show

+Showing nodes accounting for 1.11s, 99.11% of 1.12s total
+      flat  flat%   sum%        cum   cum%
+     1.10s 98.21% 98.21%      1.10s 98.21%  line1000 testdata/file1000.src:1
+         0     0% 98.21%      1.01s 90.18%  line2000 testdata/file2000.src:4
+     0.01s  0.89% 99.11%      1.01s 90.18%  line2001 testdata/file2000.src:9 (inline)

src/internal/driver/testdata/pprof.cpu.cum.lines.topproto.hide

+Showing nodes accounting for 1s, 100% of 1s total
+      flat  flat%   sum%        cum   cum%
+        1s   100%   100%         1s   100%  mangled1000 testdata/file1000.src:1
+         0     0%   100%          0     0%  mangled2000 testdata/file2000.src:4
+         0     0%   100%          0     0%  mangled2001 testdata/file2000.src:9

src/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
+         .          .       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
+         .          .       3003: instruction four
+         .          .       3004: instruction five

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

+
+<!DOCTYPE html>
+<html>
+<head>
+<title>Pprof listing</title>
+<style type="text/css">
+body {
+font-family: sans-serif;
+}
+h1 {
+  font-size: 1.5em;
+  margin-bottom: 4px;
+}
+.legend {
+  font-size: 1.25em;
+}
+.line {
+color: #aaaaaa;
+}
+.nop {
+color: #aaaaaa;
+}
+.unimportant {
+color: #cccccc;
+}
+.disasmloc {
+color: #000000;
+}
+.deadsrc {
+cursor: pointer;
+}
+.deadsrc:hover {
+background-color: #eeeeee;
+}
+.livesrc {
+color: #0000ff;
+cursor: pointer;
+}
+.livesrc:hover {
+background-color: #eeeeee;
+}
+.asm {
+color: #008800;
+display: none;
+}
+</style>
+<script type="text/javascript">
+function pprof_toggle_asm(e) {
+  var target;
+  if (!e) e = window.event;
+  if (e.target) target = e.target;
+  else if (e.srcElement) target = e.srcElement;
+
+  if (target) {
+    var asm = target.nextSibling;
+    if (asm && asm.className == "asm") {
+      asm.style.display = (asm.style.display == "block" ? "" : "block");
+      e.preventDefault();
+      return false;
+    }
+  }
+}
+</script>
+</head>
+<body>
+
+<div class="legend">File: testbinary<br>
+Type: cpu<br>
+Duration: 10s, Total samples = 1.12s (11.20%)<br>Total: 1.12s</div><h1>line1000</h1>testdata/file1000.src
+<pre onClick="pprof_toggle_asm()">
+  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>
+                   .          .     1001: instruction two                                  <span class=disasmloc></span>
+                   .          .     1002: instruction three                                <span class=disasmloc></span>
+                   .          .     1003: instruction four                                 <span class=disasmloc></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>
+</pre>
+<h1>line3000</h1>testdata/file3000.src
+<pre onClick="pprof_toggle_asm()">
+  Total:        10ms      1.12s (flat, cum)   100%
+<span class=line>      1</span> <span class=nop>           .          . line1 </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=deadsrc>        10ms      1.01s line6 </span><span class=asm>                10ms      1.01s     3000: instruction one                                  <span class=disasmloc>testdata/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>
+                   .          .     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>
+<span class=line>     10</span> <span class=nop>           .          . line0 </span>
+<span class=line>     11</span> <span class=nop>           .          . line1 </span>
+<span class=line>     12</span> <span class=nop>           .          . line2 </span>
+<span class=line>     13</span> <span class=nop>           .          . line3 </span>
+<span class=line>     14</span> <span class=nop>           .          . line4 </span>
+</pre>
+
+</body>
+</html>
+

src/internal/driver/testdata/pprof.cpu.flat.functions.dot

+digraph "testbinary" {
+node [style=filled fillcolor="#f8f8f8"]
+subgraph cluster_L { "File: testbinary" [shape=box fontsize=16 label="File: testbinary\lType: cpu\lDuration: 10s, Total samples = 1.12s (11.20%)\lShowing nodes accounting for 1.12s, 100% of 1.12s total\l"] }
+N1 [label="line1000\nfile1000.src\n1.10s (98.21%)" fontsize=24 shape=box tooltip="line1000 testdata/file1000.src (1.10s)" color="#b20000" fillcolor="#edd5d5"]
+N1_0 [label = "key1:tag1\nkey2:tag1" fontsize=8 shape=box3d tooltip="1s"]
+N1 -> N1_0 [label=" 1s" weight=100 tooltip="1s" labeltooltip="1s"]
+N1_1 [label = "key1:tag2\nkey3:tag2" fontsize=8 shape=box3d tooltip="0.10s"]
+N1 -> N1_1 [label=" 0.10s" weight=100 tooltip="0.10s" labeltooltip="0.10s"]
+N2 [label="line3000\nfile3000.src\n0 of 1.12s (100%)" fontsize=8 shape=box tooltip="line3000 testdata/file3000.src (1.12s)" color="#b20000" fillcolor="#edd5d5"]
+N3 [label="line3001\nfile3000.src\n0 of 1.11s (99.11%)" fontsize=8 shape=box tooltip="line3001 testdata/file3000.src (1.11s)" color="#b20000" fillcolor="#edd5d5"]
+N4 [label="line3002\nfile3000.src\n0.01s (0.89%)\nof 1.02s (91.07%)" fontsize=10 shape=box tooltip="line3002 testdata/file3000.src (1.02s)" color="#b20400" fillcolor="#edd6d5"]
+N5 [label="line2001\nfile2000.src\n0.01s (0.89%)\nof 1.01s (90.18%)" fontsize=10 shape=box tooltip="line2001 testdata/file2000.src (1.01s)" color="#b20500" fillcolor="#edd6d5"]
+N6 [label="line2000\nfile2000.src\n0 of 1.01s (90.18%)" fontsize=8 shape=box tooltip="line2000 testdata/file2000.src (1.01s)" color="#b20500" fillcolor="#edd6d5"]
+N2 -> N3 [label=" 1.11s\n (inline)" weight=100 penwidth=5 color="#b20000" tooltip="line3000 testdata/file3000.src -> line3001 testdata/file3000.src (1.11s)" labeltooltip="line3000 testdata/file3000.src -> line3001 testdata/file3000.src (1.11s)"]
+N6 -> N5 [label=" 1.01s\n (inline)" weight=91 penwidth=5 color="#b20500" tooltip="line2000 testdata/file2000.src -> line2001 testdata/file2000.src (1.01s)" labeltooltip="line2000 testdata/file2000.src -> line2001 testdata/file2000.src (1.01s)"]
+N3 -> N4 [label=" 1.01s\n (inline)" weight=91 penwidth=5 color="#b20500" tooltip="line3001 testdata/file3000.src -> line3002 testdata/file3000.src (1.01s)" labeltooltip="line3001 testdata/file3000.src -> line3002 testdata/file3000.src (1.01s)"]
+N4 -> N6 [label=" 1.01s" weight=91 penwidth=5 color="#b20500" tooltip="line3002 testdata/file3000.src -> line2000 testdata/file2000.src (1.01s)" labeltooltip="line3002 testdata/file3000.src -> line2000 testdata/file2000.src (1.01s)"]
+N5 -> N1 [label=" 1s" weight=90 penwidth=5 color="#b20500" tooltip="line2001 testdata/file2000.src -> line1000 testdata/file1000.src (1s)" labeltooltip="line2001 testdata/file2000.src -> line1000 testdata/file1000.src (1s)"]
+N3 -> N1 [label=" 0.10s" weight=9 color="#b28b62" tooltip="line3001 testdata/file3000.src -> line1000 testdata/file1000.src (0.10s)" labeltooltip="line3001 testdata/file3000.src -> line1000 testdata/file1000.src (0.10s)"]
+}

src/internal/driver/testdata/pprof.cpu.flat.functions.text

+Showing nodes accounting for 1.12s, 100% of 1.12s total
+      flat  flat%   sum%        cum   cum%
+     1.10s 98.21% 98.21%      1.10s 98.21%  line1000 testdata/file1000.src
+     0.01s  0.89% 99.11%      1.01s 90.18%  line2001 testdata/file2000.src (inline)
+     0.01s  0.89%   100%      1.02s 91.07%  line3002 testdata/file3000.src (inline)
+         0     0%   100%      1.01s 90.18%  line2000 testdata/file2000.src
+         0     0%   100%      1.12s   100%  line3000 testdata/file3000.src
+         0     0%   100%      1.11s 99.11%  line3001 testdata/file3000.src (inline)

src/internal/driver/testdata/pprof.cpu.peek

+Showing nodes accounting for 1.12s, 100% of 1.12s total
+----------------------------------------------------------+-------------
+      flat  flat%   sum%        cum   cum%   calls calls% + context 	 	 
+----------------------------------------------------------+-------------
+                                             1.01s   100% |   line2000 testdata/file2000.src (inline)
+     0.01s  0.89%  0.89%      1.01s 90.18%                | line2001 testdata/file2000.src
+                                                1s 99.01% |   line1000 testdata/file1000.src
+----------------------------------------------------------+-------------
+                                             1.11s   100% |   line3000 testdata/file3000.src (inline)
+         0     0%  0.89%      1.11s 99.11%                | line3001 testdata/file3000.src
+                                             1.01s 90.99% |   line3002 testdata/file3000.src (inline)
+                                             0.10s  9.01% |   line1000 testdata/file1000.src
+----------------------------------------------------------+-------------

src/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>

src/internal/driver/testdata/pprof.cpu.tags

+key1: Total 1120
+      1000 (89.29%): tag1
+       100 ( 8.93%): tag2
+        10 ( 0.89%): tag3
+        10 ( 0.89%): tag4
+
+key2: Total 1020
+      1010 (99.02%): tag1
+        10 ( 0.98%): tag2
+
+key3: Total 100
+       100 (  100%): tag2
+

src/internal/driver/testdata/pprof.cpu.tags.focus.ignore

+key1: Total 100
+       100 (  100%): tag2
+
+key3: Total 100
+       100 (  100%): tag2
+

src/internal/driver/testdata/pprof.cpu.traces

+File: testbinary
+Type: cpu
+Duration: 10s, Total samples = 1.12s (11.20%)
+-----------+-------------------------------------------------------
+      key1:  tag1
+      key2:  tag1
+        1s   line1000 testdata/file1000.src
+             line2001 testdata/file2000.src
+             line2000 testdata/file2000.src
+             line3002 testdata/file3000.src
+             line3001 testdata/file3000.src
+             line3000 testdata/file3000.src
+-----------+-------------------------------------------------------
+      key1:  tag2
+      key3:  tag2
+     100ms   line1000 testdata/file1000.src
+             line3001 testdata/file3000.src
+             line3000 testdata/file3000.src
+-----------+-------------------------------------------------------
+      key1:  tag3
+      key2:  tag2
+      10ms   line2001 testdata/file2000.src
+             line2000 testdata/file2000.src
+             line3002 testdata/file3000.src
+             line3000 testdata/file3000.src
+-----------+-------------------------------------------------------
+      key1:  tag4
+      key2:  tag1
+      10ms   line3002 testdata/file3000.src
+             line3001 testdata/file3000.src
+             line3000 testdata/file3000.src
+-----------+-------------------------------------------------------

src/internal/driver/testdata/pprof.cpusmall.flat.addresses.tree

+Showing nodes accounting for 4s, 100% of 4s total
+Showing top 4 nodes out of 5 (cum >= 2s)
+----------------------------------------------------------+-------------
+      flat  flat%   sum%        cum   cum%   calls calls% + context 	 	 
+----------------------------------------------------------+-------------
+                                                1s   100% |   0000000000003000 [testbinary]
+        1s 25.00% 25.00%         1s 25.00%                | 0000000000001000 [testbinary]
+----------------------------------------------------------+-------------
+        1s 25.00% 50.00%         2s 50.00%                | 0000000000003000 [testbinary]
+                                                1s 50.00% |   0000000000001000 [testbinary]
+----------------------------------------------------------+-------------
+                                                1s   100% |   0000000000005000 [testbinary]
+        1s 25.00% 75.00%         1s 25.00%                | 0000000000004000 [testbinary]
+----------------------------------------------------------+-------------
+        1s 25.00%   100%         2s 50.00%                | 0000000000005000 [testbinary]
+                                                1s 50.00% |   0000000000004000 [testbinary]
+----------------------------------------------------------+-------------

src/internal/driver/testdata/pprof.heap.callgrind

+events: inuse_space(MB)
+fl=(1) testdata/file2000.src
+fn=(1) line2001
+2 62
+cfl=(2) testdata/file1000.src
+cfn=(2) line1000
+calls=0 1
+2 0
+
+fl=(3) testdata/file3000.src
+fn=(3) line3002
+3 31
+cfl=(1)
+cfn=(4) line2000
+calls=0 3
+3 63
+
+fl=(2)
+fn=(2)
+1 4
+
+fl=(1)
+fn=(4)
+3 0
+cfl=(1)
+cfn=(1)
+calls=0 2
+3 63
+
+fl=(3)
+fn=(5) line3000
+4 0
+cfl=(3)
+cfn=(3)
+calls=0 3
+4 62
+cfl=(3)
+cfn=(6) line3001
+calls=0 2
+4 36
+
+fl=(3)
+fn=(6)
+2 0
+cfl=(3)
+cfn=(3)
+calls=0 3
+2 32
+cfl=(2)
+cfn=(2)
+calls=0 1
+2 3
+

src/internal/driver/testdata/pprof.heap.cum.lines.tree.focus

+Showing nodes accounting for 62.50MB, 63.37% of 98.63MB total
+Dropped 2 nodes (cum <= 4.93MB)
+----------------------------------------------------------+-------------
+      flat  flat%   sum%        cum   cum%   calls calls% + context 	 	 
+----------------------------------------------------------+-------------
+                                           63.48MB   100% |   line3002 testdata/file3000.src:3
+         0     0%     0%    63.48MB 64.36%                | line2000 testdata/file2000.src:3
+                                           63.48MB   100% |   line2001 testdata/file2000.src:2 (inline)
+----------------------------------------------------------+-------------
+                                           63.48MB   100% |   line2000 testdata/file2000.src:3 (inline)
+   62.50MB 63.37% 63.37%    63.48MB 64.36%                | line2001 testdata/file2000.src:2
+----------------------------------------------------------+-------------
+         0     0% 63.37%    63.48MB 64.36%                | line3000 testdata/file3000.src:4
+                                           63.48MB   100% |   line3002 testdata/file3000.src:3 (inline)
+----------------------------------------------------------+-------------
+                                           63.48MB   100% |   line3000 testdata/file3000.src:4 (inline)
+         0     0% 63.37%    63.48MB 64.36%                | line3002 testdata/file3000.src:3
+                                           63.48MB   100% |   line2000 testdata/file2000.src:3
+----------------------------------------------------------+-------------

src/internal/driver/testdata/pprof.heap.cum.relative_percentages.tree.focus

+Showing nodes accounting for 62.50MB, 98.46% of 63.48MB total
+Dropped 2 nodes (cum <= 3.17MB)
+----------------------------------------------------------+-------------
+      flat  flat%   sum%        cum   cum%   calls calls% + context 	 	 
+----------------------------------------------------------+-------------
+                                           63.48MB   100% |   line3002 testdata/file3000.src
+         0     0%     0%    63.48MB   100%                | line2000 testdata/file2000.src
+                                           63.48MB   100% |   line2001 testdata/file2000.src (inline)
+----------------------------------------------------------+-------------
+                                           63.48MB   100% |   line2000 testdata/file2000.src (inline)
+   62.50MB 98.46% 98.46%    63.48MB   100%                | line2001 testdata/file2000.src
+----------------------------------------------------------+-------------
+         0     0% 98.46%    63.48MB   100%                | line3000 testdata/file3000.src
+                                           63.48MB   100% |   line3002 testdata/file3000.src (inline)
+----------------------------------------------------------+-------------
+                                           63.48MB   100% |   line3000 testdata/file3000.src (inline)
+         0     0% 98.46%    63.48MB   100%                | line3002 testdata/file3000.src
+                                           63.48MB   100% |   line2000 testdata/file2000.src
+----------------------------------------------------------+-------------

src/internal/driver/testdata/pprof.heap.flat.files.seconds.text

+Showing nodes accounting for 0, 0% of 0 total
+      flat  flat%   sum%        cum   cum%

src/internal/driver/testdata/pprof.heap.flat.files.text

+Showing nodes accounting for 93.75MB, 95.05% of 98.63MB total
+Dropped 1 node (cum <= 4.93MB)
+      flat  flat%   sum%        cum   cum%
+   62.50MB 63.37% 63.37%    63.48MB 64.36%  testdata/file2000.src
+   31.25MB 31.68% 95.05%    98.63MB   100%  testdata/file3000.src

src/internal/driver/testdata/pprof.heap.flat.inuse_objects.text

+Showing nodes accounting for 150, 100% of 150 total
+      flat  flat%   sum%        cum   cum%
+        80 53.33% 53.33%        130 86.67%  line3002 testdata/file3000.src (inline)
+        40 26.67% 80.00%         50 33.33%  line2001 testdata/file2000.src (inline)
+        30 20.00%   100%         30 20.00%  line1000 testdata/file1000.src
+         0     0%   100%         50 33.33%  line2000 testdata/file2000.src
+         0     0%   100%        150   100%  line3000 testdata/file3000.src
+         0     0%   100%        110 73.33%  line3001 testdata/file3000.src (inline)

src/internal/driver/testdata/pprof.heap.flat.inuse_space.dot.focus

+digraph "." {
+node [style=filled fillcolor="#f8f8f8"]
+subgraph cluster_L { "Build ID: buildid" [shape=box fontsize=16 label="Build ID: buildid\lType: inuse_space\lShowing nodes accounting for 62.50MB, 63.37% of 98.63MB total\l"] }
+N1 [label="line2001\nfile2000.src\n62.50MB (63.37%)" fontsize=24 shape=box tooltip="line2001 testdata/file2000.src (62.50MB)" color="#b21600" fillcolor="#edd8d5"]
+NN1_0 [label = "1.56MB" fontsize=8 shape=box3d tooltip="62.50MB"]
+N1 -> NN1_0 [label=" 62.50MB" weight=100 tooltip="62.50MB" labeltooltip="62.50MB"]
+N2 [label="line3000\nfile3000.src\n0 of 62.50MB (63.37%)" fontsize=8 shape=box tooltip="line3000 testdata/file3000.src (62.50MB)" color="#b21600" fillcolor="#edd8d5"]
+N3 [label="line2000\nfile2000.src\n0 of 62.50MB (63.37%)" fontsize=8 shape=box tooltip="line2000 testdata/file2000.src (62.50MB)" color="#b21600" fillcolor="#edd8d5"]
+N4 [label="line3002\nfile3000.src\n0 of 62.50MB (63.37%)" fontsize=8 shape=box tooltip="line3002 testdata/file3000.src (62.50MB)" color="#b21600" fillcolor="#edd8d5"]
+N3 -> N1 [label=" 62.50MB\n (inline)" weight=64 penwidth=4 color="#b21600" tooltip="line2000 testdata/file2000.src -> line2001 testdata/file2000.src (62.50MB)" labeltooltip="line2000 testdata/file2000.src -> line2001 testdata/file2000.src (62.50MB)"]
+N2 -> N4 [label=" 62.50MB\n (inline)" weight=64 penwidth=4 color="#b21600" tooltip="line3000 testdata/file3000.src -> line3002 testdata/file3000.src (62.50MB)" labeltooltip="line3000 testdata/file3000.src -> line3002 testdata/file3000.src (62.50MB)"]
+N4 -> N3 [label=" 62.50MB" weight=64 penwidth=4 color="#b21600" tooltip="line3002 testdata/file3000.src -> line2000 testdata/file2000.src (62.50MB)" labeltooltip="line3002 testdata/file3000.src -> line2000 testdata/file2000.src (62.50MB)"]
+}

src/internal/driver/testdata/pprof.heap.flat.inuse_space.dot.focus.ignore

+digraph "." {
+node [style=filled fillcolor="#f8f8f8"]
+subgraph cluster_L { "Build ID: buildid" [shape=box fontsize=16 label="Build ID: buildid\lType: inuse_space\lShowing nodes accounting for 36.13MB, 36.63% of 98.63MB total\lDropped 2 nodes (cum <= 4.93MB)\l"] }
+N1 [label="line3002\nfile3000.src\n31.25MB (31.68%)\nof 32.23MB (32.67%)" fontsize=24 shape=box tooltip="line3002 testdata/file3000.src (32.23MB)" color="#b23200" fillcolor="#eddcd5"]
+NN1_0 [label = "400kB" fontsize=8 shape=box3d tooltip="31.25MB"]
+N1 -> NN1_0 [label=" 31.25MB" weight=100 tooltip="31.25MB" labeltooltip="31.25MB"]
+N2 [label="line3000\nfile3000.src\n0 of 36.13MB (36.63%)" fontsize=8 shape=box tooltip="line3000 testdata/file3000.src (36.13MB)" color="#b22e00" fillcolor="#eddbd5"]
+N3 [label="line3001\nfile3000.src\n0 of 36.13MB (36.63%)" fontsize=8 shape=box tooltip="line3001 testdata/file3000.src (36.13MB)" color="#b22e00" fillcolor="#eddbd5"]
+N4 [label="line1000\nfile1000.src\n4.88MB (4.95%)" fontsize=15 shape=box tooltip="line1000 testdata/file1000.src (4.88MB)" color="#b2a086" fillcolor="#edeae7"]
+NN4_0 [label = "200kB" fontsize=8 shape=box3d tooltip="3.91MB"]
+N4 -> NN4_0 [label=" 3.91MB" weight=100 tooltip="3.91MB" labeltooltip="3.91MB"]
+N2 -> N3 [label=" 36.13MB\n (inline)" weight=37 penwidth=2 color="#b22e00" tooltip="line3000 testdata/file3000.src -> line3001 testdata/file3000.src (36.13MB)" labeltooltip="line3000 testdata/file3000.src -> line3001 testdata/file3000.src (36.13MB)"]
+N3 -> N1 [label=" 32.23MB\n (inline)" weight=33 penwidth=2 color="#b23200" tooltip="line3001 testdata/file3000.src -> line3002 testdata/file3000.src (32.23MB)" labeltooltip="line3001 testdata/file3000.src -> line3002 testdata/file3000.src (32.23MB)"]
+N3 -> N4 [label=" 3.91MB" weight=4 color="#b2a58f" tooltip="line3001 testdata/file3000.src -> line1000 testdata/file1000.src (3.91MB)" labeltooltip="line3001 testdata/file3000.src -> line1000 testdata/file1000.src (3.91MB)"]
+}

src/internal/driver/testdata/pprof.heap.flat.lines.dot.focus

+digraph "." {
+node [style=filled fillcolor="#f8f8f8"]
+subgraph cluster_L { "Build ID: buildid" [shape=box fontsize=16 label="Build ID: buildid\lType: inuse_space\lShowing nodes accounting for 67.38MB, 68.32% of 98.63MB total\l"] }
+N1 [label="line3000\nfile3000.src:4\n0 of 67.38MB (68.32%)" fontsize=8 shape=box tooltip="line3000 testdata/file3000.src:4 (67.38MB)" color="#b21300" fillcolor="#edd7d5"]
+N2 [label="line2001\nfile2000.src:2\n62.50MB (63.37%)\nof 63.48MB (64.36%)" fontsize=24 shape=box tooltip="line2001 testdata/file2000.src:2 (63.48MB)" color="#b21600" fillcolor="#edd8d5"]
+NN2_0 [label = "1.56MB" fontsize=8 shape=box3d tooltip="62.50MB"]
+N2 -> NN2_0 [label=" 62.50MB" weight=100 tooltip="62.50MB" labeltooltip="62.50MB"]
+N3 [label="line1000\nfile1000.src:1\n4.88MB (4.95%)" fontsize=13 shape=box tooltip="line1000 testdata/file1000.src:1 (4.88MB)" color="#b2a086" fillcolor="#edeae7"]
+NN3_0 [label = "200kB" fontsize=8 shape=box3d tooltip="3.91MB"]
+N3 -> NN3_0 [label=" 3.91MB" weight=100 tooltip="3.91MB" labeltooltip="3.91MB"]
+N4 [label="line3002\nfile3000.src:3\n0 of 63.48MB (64.36%)" fontsize=8 shape=box tooltip="line3002 testdata/file3000.src:3 (63.48MB)" color="#b21600" fillcolor="#edd8d5"]
+N5 [label="line3001\nfile3000.src:2\n0 of 4.88MB (4.95%)" fontsize=8 shape=box tooltip="line3001 testdata/file3000.src:2 (4.88MB)" color="#b2a086" fillcolor="#edeae7"]
+N6 [label="line2000\nfile2000.src:3\n0 of 63.48MB (64.36%)" fontsize=8 shape=box tooltip="line2000 testdata/file2000.src:3 (63.48MB)" color="#b21600" fillcolor="#edd8d5"]
+N6 -> N2 [label=" 63.48MB\n (inline)" weight=65 penwidth=4 color="#b21600" tooltip="line2000 testdata/file2000.src:3 -> line2001 testdata/file2000.src:2 (63.48MB)" labeltooltip="line2000 testdata/file2000.src:3 -> line2001 testdata/file2000.src:2 (63.48MB)"]
+N4 -> N6 [label=" 63.48MB" weight=65 penwidth=4 color="#b21600" tooltip="line3002 testdata/file3000.src:3 -> line2000 testdata/file2000.src:3 (63.48MB)" labeltooltip="line3002 testdata/file3000.src:3 -> line2000 testdata/file2000.src:3 (63.48MB)"]
+N1 -> N4 [label=" 62.50MB\n (inline)" weight=64 penwidth=4 color="#b21600" tooltip="line3000 testdata/file3000.src:4 -> line3002 testdata/file3000.src:3 (62.50MB)" labeltooltip="line3000 testdata/file3000.src:4 -> line3002 testdata/file3000.src:3 (62.50MB)"]
+N1 -> N5 [label=" 4.88MB\n (inline)" weight=5 color="#b2a086" tooltip="line3000 testdata/file3000.src:4 -> line3001 testdata/file3000.src:2 (4.88MB)" labeltooltip="line3000 testdata/file3000.src:4 -> line3001 testdata/file3000.src:2 (4.88MB)"]
+N5 -> N3 [label=" 3.91MB" weight=4 color="#b2a58f" tooltip="line3001 testdata/file3000.src:2 -> line1000 testdata/file1000.src:1 (3.91MB)" labeltooltip="line3001 testdata/file3000.src:2 -> line1000 testdata/file1000.src:1 (3.91MB)"]
+N2 -> N3 [label=" 0.98MB" color="#b2b0a9" tooltip="line2001 testdata/file2000.src:2 -> line1000 testdata/file1000.src:1 (0.98MB)" labeltooltip="line2001 testdata/file2000.src:2 -> line1000 testdata/file1000.src:1 (0.98MB)" minlen=2]
+N5 -> N4 [label=" 0.98MB\n (inline)" color="#b2b0a9" tooltip="line3001 testdata/file3000.src:2 -> line3002 testdata/file3000.src:3 (0.98MB)" labeltooltip="line3001 testdata/file3000.src:2 -> line3002 testdata/file3000.src:3 (0.98MB)"]
+}

src/internal/driver/testdata/pprof.heap_alloc.flat.alloc_objects.text

+Showing nodes accounting for 150, 100% of 150 total
+      flat  flat%   sum%        cum   cum%
+        80 53.33% 53.33%        130 86.67%  line3002 testdata/file3000.src (inline)
+        40 26.67% 80.00%         50 33.33%  line2001 testdata/file2000.src (inline)
+        30 20.00%   100%         30 20.00%  line1000 testdata/file1000.src
+         0     0%   100%         50 33.33%  line2000 testdata/file2000.src
+         0     0%   100%        150   100%  line3000 testdata/file3000.src
+         0     0%   100%        110 73.33%  line3001 testdata/file3000.src (inline)

src/internal/driver/testdata/pprof.heap_alloc.flat.alloc_space.dot.focus

+digraph "." {
+node [style=filled fillcolor="#f8f8f8"]
+subgraph cluster_L { "Build ID: buildid" [shape=box fontsize=16 label="Build ID: buildid\lType: alloc_space\lShowing nodes accounting for 93.75MB, 95.05% of 98.63MB total\lDropped 1 node (cum <= 4.93MB)\l"] }
+N1 [label="line3002\nfile3000.src\n31.25MB (31.68%)\nof 94.73MB (96.04%)" fontsize=20 shape=box tooltip="line3002 testdata/file3000.src (94.73MB)" color="#b20200" fillcolor="#edd5d5"]
+NN1_0 [label = "400kB" fontsize=8 shape=box3d tooltip="31.25MB"]
+N1 -> NN1_0 [label=" 31.25MB" weight=100 tooltip="31.25MB" labeltooltip="31.25MB"]
+N2 [label="line3000\nfile3000.src\n0 of 98.63MB (100%)" fontsize=8 shape=box tooltip="line3000 testdata/file3000.src (98.63MB)" color="#b20000" fillcolor="#edd5d5"]
+N3 [label="line2001\nfile2000.src\n62.50MB (63.37%)\nof 63.48MB (64.36%)" fontsize=24 shape=box tooltip="line2001 testdata/file2000.src (63.48MB)" color="#b21600" fillcolor="#edd8d5"]
+NN3_0 [label = "1.56MB" fontsize=8 shape=box3d tooltip="62.50MB"]
+N3 -> NN3_0 [label=" 62.50MB" weight=100 tooltip="62.50MB" labeltooltip="62.50MB"]
+N4 [label="line2000\nfile2000.src\n0 of 63.48MB (64.36%)" fontsize=8 shape=box tooltip="line2000 testdata/file2000.src (63.48MB)" color="#b21600" fillcolor="#edd8d5"]
+N5 [label="line3001\nfile3000.src\n0 of 36.13MB (36.63%)" fontsize=8 shape=box tooltip="line3001 testdata/file3000.src (36.13MB)" color="#b22e00" fillcolor="#eddbd5"]
+N4 -> N3 [label=" 63.48MB\n (inline)" weight=65 penwidth=4 color="#b21600" tooltip="line2000 testdata/file2000.src -> line2001 testdata/file2000.src (63.48MB)" labeltooltip="line2000 testdata/file2000.src -> line2001 testdata/file2000.src (63.48MB)"]
+N1 -> N4 [label=" 63.48MB" weight=65 penwidth=4 color="#b21600" tooltip="line3002 testdata/file3000.src -> line2000 testdata/file2000.src (63.48MB)" labeltooltip="line3002 testdata/file3000.src -> line2000 testdata/file2000.src (63.48MB)" minlen=2]
+N2 -> N1 [label=" 62.50MB\n (inline)" weight=64 penwidth=4 color="#b21600" tooltip="line3000 testdata/file3000.src -> line3002 testdata/file3000.src (62.50MB)" labeltooltip="line3000 testdata/file3000.src -> line3002 testdata/file3000.src (62.50MB)"]
+N2 -> N5 [label=" 36.13MB\n (inline)" weight=37 penwidth=2 color="#b22e00" tooltip="line3000 testdata/file3000.src -> line3001 testdata/file3000.src (36.13MB)" labeltooltip="line3000 testdata/file3000.src -> line3001 testdata/file3000.src (36.13MB)"]
+N5 -> N1 [label=" 32.23MB\n (inline)" weight=33 penwidth=2 color="#b23200" tooltip="line3001 testdata/file3000.src -> line3002 testdata/file3000.src (32.23MB)" labeltooltip="line3001 testdata/file3000.src -> line3002 testdata/file3000.src (32.23MB)"]
+}

src/internal/driver/testdata/pprof.heap_alloc.flat.alloc_space.dot.hide

+digraph "." {
+node [style=filled fillcolor="#f8f8f8"]
+subgraph cluster_L { "Build ID: buildid" [shape=box fontsize=16 label="Build ID: buildid\lType: alloc_space\lShowing nodes accounting for 93.75MB, 95.05% of 98.63MB total\lDropped 1 node (cum <= 4.93MB)\l"] }
+N1 [label="line3000\nfile3000.src\n62.50MB (63.37%)\nof 98.63MB (100%)" fontsize=24 shape=box tooltip="line3000 testdata/file3000.src (98.63MB)" color="#b20000" fillcolor="#edd5d5"]
+NN1_0 [label = "1.56MB" fontsize=8 shape=box3d tooltip="62.50MB"]
+N1 -> NN1_0 [label=" 62.50MB" weight=100 tooltip="62.50MB" labeltooltip="62.50MB"]
+N2 [label="line3001\nfile3000.src\n31.25MB (31.68%)\nof 36.13MB (36.63%)" fontsize=20 shape=box tooltip="line3001 testdata/file3000.src (36.13MB)" color="#b22e00" fillcolor="#eddbd5"]
+NN2_0 [label = "400kB" fontsize=8 shape=box3d tooltip="31.25MB"]
+N2 -> NN2_0 [label=" 31.25MB" weight=100 tooltip="31.25MB" labeltooltip="31.25MB"]
+N1 -> N2 [label=" 36.13MB\n (inline)" weight=37 penwidth=2 color="#b22e00" tooltip="line3000 testdata/file3000.src -> line3001 testdata/file3000.src (36.13MB)" labeltooltip="line3000 testdata/file3000.src -> line3001 testdata/file3000.src (36.13MB)" minlen=2]
+}

src/internal/driver/testdata/pprof.unknown.flat.functions.text

+Showing nodes accounting for 1.12s, 100% of 1.12s total
+      flat  flat%   sum%        cum   cum%
+     1.10s 98.21% 98.21%      1.10s 98.21%  line1000 testdata/file1000.src
+     0.01s  0.89% 99.11%      1.01s 90.18%  line2001 testdata/file2000.src (inline)
+     0.01s  0.89%   100%      1.02s 91.07%  line3002 testdata/file3000.src (inline)
+         0     0%   100%      1.01s 90.18%  line2000 testdata/file2000.src
+         0     0%   100%      1.12s   100%  line3000 testdata/file3000.src
+         0     0%   100%      1.11s 99.11%  line3001 testdata/file3000.src (inline)

src/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

src/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

src/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

src/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

src/internal/elfexec/elfexec.go

+// 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.
+
+// Package elfexec provides utility routines to examine ELF binaries.
+package elfexec
+
+import (
+	"bufio"
+	"debug/elf"
+	"encoding/binary"
+	"fmt"
+	"io"
+)
+
+const (
+	maxNoteSize        = 1 << 20 // in bytes
+	noteTypeGNUBuildID = 3
+)
+
+// elfNote is the payload of a Note Section in an ELF file.
+type elfNote struct {
+	Name string // Contents of the "name" field, omitting the trailing zero byte.
+	Desc []byte // Contents of the "desc" field.
+	Type uint32 // Contents of the "type" field.
+}
+
+// parseNotes returns the notes from a SHT_NOTE section or PT_NOTE segment.
+func parseNotes(reader io.Reader, alignment int, order binary.ByteOrder) ([]elfNote, error) {
+	r := bufio.NewReader(reader)
+
+	// padding returns the number of bytes required to pad the given size to an
+	// alignment boundary.
+	padding := func(size int) int {
+		return ((size + (alignment - 1)) &^ (alignment - 1)) - size
+	}
+
+	var notes []elfNote
+	for {
+		noteHeader := make([]byte, 12) // 3 4-byte words
+		if _, err := io.ReadFull(r, noteHeader); err == io.EOF {
+			break
+		} else if err != nil {
+			return nil, err
+		}
+		namesz := order.Uint32(noteHeader[0:4])
+		descsz := order.Uint32(noteHeader[4:8])
+		typ := order.Uint32(noteHeader[8:12])
+
+		if uint64(namesz) > uint64(maxNoteSize) {
+			return nil, fmt.Errorf("note name too long (%d bytes)", namesz)
+		}
+		var name string
+		if namesz > 0 {
+			// Documentation differs as to whether namesz is meant to include the
+			// trailing zero, but everyone agrees that name is null-terminated.
+			// So we'll just determine the actual length after the fact.
+			var err error
+			name, err = r.ReadString('\x00')
+			if err == io.EOF {
+				return nil, fmt.Errorf("missing note name (want %d bytes)", namesz)
+			} else if err != nil {
+				return nil, err
+			}
+			namesz = uint32(len(name))
+			name = name[:len(name)-1]
+		}
+
+		// Drop padding bytes until the desc field.
+		for n := padding(len(noteHeader) + int(namesz)); n > 0; n-- {
+			if _, err := r.ReadByte(); err == io.EOF {
+				return nil, fmt.Errorf(
+					"missing %d bytes of padding after note name", n)
+			} else if err != nil {
+				return nil, err
+			}
+		}
+
+		if uint64(descsz) > uint64(maxNoteSize) {
+			return nil, fmt.Errorf("note desc too long (%d bytes)", descsz)
+		}
+		desc := make([]byte, int(descsz))
+		if _, err := io.ReadFull(r, desc); err == io.EOF {
+			return nil, fmt.Errorf("missing desc (want %d bytes)", len(desc))
+		} else if err != nil {
+			return nil, err
+		}
+
+		notes = append(notes, elfNote{Name: name, Desc: desc, Type: typ})
+
+		// Drop padding bytes until the next note or the end of the section,
+		// whichever comes first.
+		for n := padding(len(desc)); n > 0; n-- {
+			if _, err := r.ReadByte(); err == io.EOF {
+				// We hit the end of the section before an alignment boundary.
+				// This can happen if this section is at the end of the file or the next
+				// section has a smaller alignment requirement.
+				break
+			} else if err != nil {
+				return nil, err
+			}
+		}
+	}
+	return notes, nil
+}
+
+// GetBuildID returns the GNU build-ID for an ELF binary.
+//
+// If no build-ID was found but the binary was read without error, it returns
+// (nil, nil).
+func GetBuildID(binary io.ReaderAt) ([]byte, error) {
+	f, err := elf.NewFile(binary)
+	if err != nil {
+		return nil, err
+	}
+
+	findBuildID := func(notes []elfNote) ([]byte, error) {
+		var buildID []byte
+		for _, note := range notes {
+			if note.Name == "GNU" && note.Type == noteTypeGNUBuildID {
+				if buildID == nil {
+					buildID = note.Desc
+				} else {
+					return nil, fmt.Errorf("multiple build ids found, don't know which to use!")
+				}
+			}
+		}
+		return buildID, nil
+	}
+
+	for _, p := range f.Progs {
+		if p.Type != elf.PT_NOTE {
+			continue
+		}
+		notes, err := parseNotes(p.Open(), int(p.Align), f.ByteOrder)
+		if err != nil {
+			return nil, err
+		}
+		if b, err := findBuildID(notes); b != nil || err != nil {
+			return b, err
+		}
+	}
+	for _, s := range f.Sections {
+		if s.Type != elf.SHT_NOTE {
+			continue
+		}
+		notes, err := parseNotes(s.Open(), int(s.Addralign), f.ByteOrder)
+		if err != nil {
+			return nil, err
+		}
+		if b, err := findBuildID(notes); b != nil || err != nil {
+			return b, err
+		}
+	}
+	return nil, nil
+}
+
+// GetBase determines the base address to subtract from virtual
+// address to get symbol table address.  For an executable, the base
+// is 0.  Otherwise, it's a shared library, and the base is the
+// address where the mapping starts.  The kernel is special, and may
+// use the address of the _stext symbol as the mmap start.  _stext
+// offset can be obtained with `nm vmlinux | grep _stext`
+func GetBase(fh *elf.FileHeader, loadSegment *elf.ProgHeader, stextOffset *uint64, start, limit, offset uint64) (uint64, error) {
+	const pageSize = 4096
+
+	if start == 0 && offset == 0 &&
+		(limit == ^uint64(0) || limit == 0) {
+		// Some tools may introduce a fake mapping that spans the entire
+		// address space. Assume that the address has already been
+		// adjusted, so no additional base adjustment is necessary.
+		return 0, nil
+	}
+
+	switch fh.Type {
+	case elf.ET_EXEC:
+		if loadSegment == nil {
+			// Fixed-address executable, no adjustment.
+			return 0, nil
+		}
+		if start == 0 && limit != 0 {
+			// ChromeOS remaps its kernel to 0.  Nothing else should come
+			// down this path.  Empirical values:
+			//       VADDR=0xffffffff80200000
+			// stextOffset=0xffffffff80200198
+			if stextOffset != nil {
+				return -*stextOffset, nil
+			}
+			return -loadSegment.Vaddr, nil
+		}
+		if loadSegment.Vaddr-loadSegment.Off == start-offset {
+			return offset, nil
+		}
+		if loadSegment.Vaddr == start-offset {
+			return offset, nil
+		}
+		if start > loadSegment.Vaddr && limit > start && offset == 0 {
+			// Some kernels look like:
+			//       VADDR=0xffffffff80200000
+			// stextOffset=0xffffffff80200198
+			//       Start=0xffffffff83200000
+			//       Limit=0xffffffff84200000
+			//      Offset=0
+			// So the base should be:
+			if stextOffset != nil && (start%pageSize) == (*stextOffset%pageSize) {
+				// perf uses the address of _stext as start.  Some tools may
+				// adjust for this before calling GetBase, in which case the the page
+				// alignment should be different from that of stextOffset.
+				return start - *stextOffset, nil
+			}
+
+			return start - loadSegment.Vaddr, nil
+		} else if start < loadSegment.Vaddr && start%pageSize != 0 && stextOffset != nil && *stextOffset%pageSize == start%pageSize {
+			// ChromeOS remaps its kernel to 0 + start%pageSize.  Nothing
+			// else should come down this path.  Empirical values:
+			//       start=0x198 limit=0x2f9fffff offset=0
+			//       VADDR=0xffffffff81000000
+			// stextOffset=0xffffffff81000198
+			return -(*stextOffset - start), nil
+		}
+
+		return 0, fmt.Errorf("Don't know how to handle EXEC segment: %v start=0x%x limit=0x%x offset=0x%x", *loadSegment, start, limit, offset)
+	case elf.ET_REL:
+		if offset != 0 {
+			return 0, fmt.Errorf("Don't know how to handle mapping.Offset")
+		}
+		return start, nil
+	case elf.ET_DYN:
+		if offset != 0 {
+			return 0, fmt.Errorf("Don't know how to handle mapping.Offset")
+		}
+		if loadSegment == nil {
+			return start, nil
+		}
+		return start - loadSegment.Vaddr, nil
+	}
+	return 0, fmt.Errorf("Don't know how to handle FileHeader.Type %v", fh.Type)
+}

src/internal/elfexec/elfexec_test.go

+// 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.
+
+package elfexec
+
+import (
+	"debug/elf"
+	"testing"
+)
+
+func TestGetBase(t *testing.T) {
+
+	fhExec := &elf.FileHeader{
+		Type: elf.ET_EXEC,
+	}
+	fhRel := &elf.FileHeader{
+		Type: elf.ET_REL,
+	}
+	fhDyn := &elf.FileHeader{
+		Type: elf.ET_DYN,
+	}
+	lsOffset := &elf.ProgHeader{
+		Vaddr: 0x400000,
+		Off:   0x200000,
+	}
+	kernelHeader := &elf.ProgHeader{
+		Vaddr: 0xffffffff81000000,
+	}
+
+	testcases := []struct {
+		label                string
+		fh                   *elf.FileHeader
+		loadSegment          *elf.ProgHeader
+		stextOffset          *uint64
+		start, limit, offset uint64
+		want                 uint64
+		wanterr              bool
+	}{
+		{"exec", fhExec, nil, nil, 0x400000, 0, 0, 0, false},
+		{"exec offset", fhExec, lsOffset, nil, 0x400000, 0x800000, 0, 0, false},
+		{"exec offset 2", fhExec, lsOffset, nil, 0x200000, 0x600000, 0, 0, false},
+		{"exec nomap", fhExec, nil, nil, 0, 0, 0, 0, false},
+		{"exec kernel", fhExec, kernelHeader, uint64p(0xffffffff81000198), 0xffffffff82000198, 0xffffffff83000198, 0, 0x1000000, false},
+		{"exec chromeos kernel", fhExec, kernelHeader, uint64p(0xffffffff81000198), 0, 0x10197, 0, 0x7efffe68, false},
+		{"exec chromeos kernel 2", fhExec, kernelHeader, uint64p(0xffffffff81000198), 0, 0x10198, 0, 0x7efffe68, false},
+		{"exec chromeos kernel 3", fhExec, kernelHeader, uint64p(0xffffffff81000198), 0x198, 0x100000, 0, 0x7f000000, false},
+		{"exec chromeos kernel 4", fhExec, kernelHeader, uint64p(0xffffffff81200198), 0x198, 0x100000, 0, 0x7ee00000, false},
+		{"dyn", fhDyn, nil, nil, 0x200000, 0x300000, 0, 0x200000, false},
+		{"dyn offset", fhDyn, lsOffset, nil, 0x0, 0x300000, 0, 0xFFFFFFFFFFC00000, false},
+		{"dyn nomap", fhDyn, nil, nil, 0x0, 0x0, 0, 0, false},
+		{"rel", fhRel, nil, nil, 0x2000000, 0x3000000, 0, 0x2000000, false},
+		{"rel nomap", fhRel, nil, nil, 0x0, ^uint64(0), 0, 0, false},
+		{"rel offset", fhRel, nil, nil, 0x100000, 0x200000, 0x1, 0, true},
+	}
+
+	for _, tc := range testcases {
+		base, err := GetBase(tc.fh, tc.loadSegment, tc.stextOffset, tc.start, tc.limit, tc.offset)
+		if err != nil {
+			if !tc.wanterr {
+				t.Errorf("%s: want no error, got %v", tc.label, err)
+			}
+			continue
+		}
+		if tc.wanterr {
+			t.Errorf("%s: want error, got nil", tc.label)
+			continue
+		}
+		if base != tc.want {
+			t.Errorf("%s: want %x, got %x", tc.label, tc.want, base)
+		}
+	}
+}
+
+func uint64p(n uint64) *uint64 {
+	return &n
+}

src/internal/graph/dotgraph.go

+// 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.
+
+package graph
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"path/filepath"
+	"strings"
+
+	"internal/measurement"
+)
+
+// DotAttributes contains details about the graph itself, giving
+// insight into how its elements should be rendered.
+type DotAttributes struct {
+	Nodes map[*Node]*DotNodeAttributes // A map allowing each Node to have its own visualization option
+}
+
+// DotNodeAttributes contains Node specific visualization options.
+type DotNodeAttributes struct {
+	Shape       string                 // The optional shape of the node when rendered visually
+	Bold        bool                   // If the node should be bold or not
+	Peripheries int                    // An optional number of borders to place around a node
+	URL         string                 // An optional url link to add to a node
+	Formatter   func(*NodeInfo) string // An optional formatter for the node's label
+}
+
+// DotConfig contains attributes about how a graph should be
+// constructed and how it should look.
+type DotConfig struct {
+	Title  string   // The title of the DOT graph
+	Labels []string // The labels for the DOT's legend
+
+	FormatValue func(int64) string // A formatting function for values
+	Total       int64              // The total weight of the graph, used to compute percentages
+}
+
+// Compose creates and writes a in the DOT format to the writer, using
+// the configurations given.
+func ComposeDot(w io.Writer, g *Graph, a *DotAttributes, c *DotConfig) {
+	builder := &builder{w, a, c}
+
+	// Begin constructing DOT by adding a title and legend.
+	builder.start()
+	defer builder.finish()
+	builder.addLegend()
+
+	if len(g.Nodes) == 0 {
+		return
+	}
+
+	// Preprocess graph to get id map and find max flat.
+	nodeIDMap := make(map[*Node]int)
+	hasNodelets := make(map[*Node]bool)
+
+	maxFlat := float64(abs64(g.Nodes[0].Flat))
+	for i, n := range g.Nodes {
+		nodeIDMap[n] = i + 1
+		if float64(abs64(n.Flat)) > maxFlat {
+			maxFlat = float64(abs64(n.Flat))
+		}
+	}
+
+	edges := EdgeMap{}
+
+	// Add nodes and nodelets to DOT builder.
+	for _, n := range g.Nodes {
+		builder.addNode(n, nodeIDMap[n], maxFlat)
+		hasNodelets[n] = builder.addNodelets(n, nodeIDMap[n])
+
+		// Collect all edges. Use a fake node to support multiple incoming edges.
+		for _, e := range n.Out {
+			edges[&Node{}] = e
+		}
+	}
+
+	// Add edges to DOT builder. Sort edges by frequency as a hint to the graph layout engine.
+	for _, e := range edges.Sort() {
+		builder.addEdge(e, nodeIDMap[e.Src], nodeIDMap[e.Dest], hasNodelets[e.Src])
+	}
+}
+
+// builder wraps an io.Writer and understands how to compose DOT formatted elements.
+type builder struct {
+	io.Writer
+	attributes *DotAttributes
+	config     *DotConfig
+}
+
+// start generates a title and initial node in DOT format.
+func (b *builder) start() {
+	graphname := "unnamed"
+	if b.config.Title != "" {
+		graphname = b.config.Title
+	}
+	fmt.Fprintln(b, `digraph "`+graphname+`" {`)
+	fmt.Fprintln(b, `node [style=filled fillcolor="#f8f8f8"]`)
+}
+
+// finish closes the opening curly bracket in the constructed DOT buffer.
+func (b *builder) finish() {
+	fmt.Fprintln(b, "}")
+}
+
+// addLegend generates a legend in DOT format.
+func (b *builder) addLegend() {
+	labels := b.config.Labels
+	var title string
+	if len(labels) > 0 {
+		title = labels[0]
+	}
+	fmt.Fprintf(b, `subgraph cluster_L { "%s" [shape=box fontsize=16 label="%s\l"] }`+"\n", title, strings.Join(labels, `\l`))
+}
+
+// addNode generates a graph node in DOT format.
+func (b *builder) addNode(node *Node, nodeID int, maxFlat float64) {
+	flat, cum := node.Flat, node.Cum
+	attrs := b.attributes.Nodes[node]
+
+	// Populate label for node.
+	var label string
+	if attrs != nil && attrs.Formatter != nil {
+		label = attrs.Formatter(&node.Info)
+	} else {
+		label = multilinePrintableName(&node.Info)
+	}
+
+	flatValue := b.config.FormatValue(flat)
+	if flat != 0 {
+		label = label + fmt.Sprintf(`%s (%s)`,
+			flatValue,
+			strings.TrimSpace(percentage(flat, b.config.Total)))
+	} else {
+		label = label + "0"
+	}
+	cumValue := flatValue
+	if cum != flat {
+		if flat != 0 {
+			label = label + `\n`
+		} else {
+			label = label + " "
+		}
+		cumValue = b.config.FormatValue(cum)
+		label = label + fmt.Sprintf(`of %s (%s)`,
+			cumValue,
+			strings.TrimSpace(percentage(cum, b.config.Total)))
+	}
+
+	// Scale font sizes from 8 to 24 based on percentage of flat frequency.
+	// Use non linear growth to emphasize the size difference.
+	baseFontSize, maxFontGrowth := 8, 16.0
+	fontSize := baseFontSize
+	if maxFlat != 0 && flat != 0 && float64(abs64(flat)) <= maxFlat {
+		fontSize += int(math.Ceil(maxFontGrowth * math.Sqrt(float64(abs64(flat))/maxFlat)))
+	}
+
+	// Determine node shape.
+	shape := "box"
+	if attrs != nil && attrs.Shape != "" {
+		shape = attrs.Shape
+	}
+
+	// Create DOT attribute for node.
+	attr := fmt.Sprintf(`label="%s" fontsize=%d shape=%s tooltip="%s (%s)" color="%s" fillcolor="%s"`,
+		label, fontSize, shape, node.Info.PrintableName(), cumValue,
+		dotColor(float64(node.Cum)/float64(abs64(b.config.Total)), false),
+		dotColor(float64(node.Cum)/float64(abs64(b.config.Total)), true))
+
+	// Add on extra attributes if provided.
+	if attrs != nil {
+		// Make bold if specified.
+		if attrs.Bold {
+			attr += ` style="bold,filled"`
+		}
+
+		// Add peripheries if specified.
+		if attrs.Peripheries != 0 {
+			attr += fmt.Sprintf(` peripheries=%d`, attrs.Peripheries)
+		}
+
+		// Add URL if specified. target="_blank" forces the link to open in a new tab.
+		if attrs.URL != "" {
+			attr += fmt.Sprintf(` URL="%s" target="_blank"`, attrs.URL)
+		}
+	}
+
+	fmt.Fprintf(b, "N%d [%s]\n", nodeID, attr)
+}
+
+// addNodelets generates the DOT boxes for the node tags if they exist.
+func (b *builder) addNodelets(node *Node, nodeID int) bool {
+	const maxNodelets = 4    // Number of nodelets for alphanumeric labels
+	const maxNumNodelets = 4 // Number of nodelets for numeric labels
+	var nodelets string
+
+	// Populate two Tag slices, one for LabelTags and one for NumericTags.
+	var ts []*Tag
+	lnts := make(map[string][]*Tag, 0)
+	for _, t := range node.LabelTags {
+		ts = append(ts, t)
+	}
+	for l, tm := range node.NumericTags {
+		for _, t := range tm {
+			lnts[l] = append(lnts[l], t)
+		}
+	}
+
+	// For leaf nodes, print cumulative tags (includes weight from
+	// children that have been deleted).
+	// For internal nodes, print only flat tags.
+	flatTags := len(node.Out) > 0
+
+	// Select the top maxNodelets alphanumeric labels by weight.
+	SortTags(ts, flatTags)
+	if len(ts) > maxNodelets {
+		ts = ts[:maxNodelets]
+	}
+	for i, t := range ts {
+		w := t.Cum
+		if flatTags {
+			w = t.Flat
+		}
+		if w == 0 {
+			continue
+		}
+		weight := b.config.FormatValue(w)
+		nodelets += fmt.Sprintf(`N%d_%d [label = "%s" fontsize=8 shape=box3d tooltip="%s"]`+"\n", nodeID, i, t.Name, weight)
+		nodelets += fmt.Sprintf(`N%d -> N%d_%d [label=" %s" weight=100 tooltip="%s" labeltooltip="%s"]`+"\n", nodeID, nodeID, i, weight, weight, weight)
+		if nts := lnts[t.Name]; nts != nil {
+			nodelets += b.numericNodelets(nts, maxNumNodelets, flatTags, fmt.Sprintf(`N%d_%d`, nodeID, i))
+		}
+	}
+
+	if nts := lnts[""]; nts != nil {
+		nodelets += b.numericNodelets(nts, maxNumNodelets, flatTags, fmt.Sprintf(`N%d`, nodeID))
+	}
+
+	fmt.Fprint(b, nodelets)
+	return nodelets != ""
+}
+
+func (b *builder) numericNodelets(nts []*Tag, maxNumNodelets int, flatTags bool, source string) string {
+	nodelets := ""
+
+	// Collapse numeric labels into maxNumNodelets buckets, of the form:
+	// 1MB..2MB, 3MB..5MB, ...
+	for j, t := range collapsedTags(nts, maxNumNodelets, flatTags) {
+		w, attr := t.Cum, ` style="dotted"`
+		if flatTags || t.Flat == t.Cum {
+			w, attr = t.Flat, ""
+		}
+		if w != 0 {
+			weight := b.config.FormatValue(w)
+			nodelets += fmt.Sprintf(`N%s_%d [label = "%s" fontsize=8 shape=box3d tooltip="%s"]`+"\n", source, j, t.Name, weight)
+			nodelets += fmt.Sprintf(`%s -> N%s_%d [label=" %s" weight=100 tooltip="%s" labeltooltip="%s"%s]`+"\n", source, source, j, weight, weight, weight, attr)
+		}
+	}
+	return nodelets
+}
+
+// addEdge generates a graph edge in DOT format.
+func (b *builder) addEdge(edge *Edge, from, to int, hasNodelets bool) {
+	var inline string
+	if edge.Inline {
+		inline = `\n (inline)`
+	}
+	w := b.config.FormatValue(edge.Weight)
+	attr := fmt.Sprintf(`label=" %s%s"`, w, inline)
+	if b.config.Total != 0 {
+		// Note: edge.weight > b.config.Total is possible for profile diffs.
+		if weight := 1 + int(min64(abs64(edge.Weight*100/b.config.Total), 100)); weight > 1 {
+			attr = fmt.Sprintf(`%s weight=%d`, attr, weight)
+		}
+		if width := 1 + int(min64(abs64(edge.Weight*5/b.config.Total), 5)); width > 1 {
+			attr = fmt.Sprintf(`%s penwidth=%d`, attr, width)
+		}
+		attr = fmt.Sprintf(`%s color="%s"`, attr,
+			dotColor(float64(edge.Weight)/float64(abs64(b.config.Total)), false))
+	}
+	arrow := "->"
+	if edge.Residual {
+		arrow = "..."
+	}
+	tooltip := fmt.Sprintf(`"%s %s %s (%s)"`,
+		edge.Src.Info.PrintableName(), arrow, edge.Dest.Info.PrintableName(), w)
+	attr = fmt.Sprintf(`%s tooltip=%s labeltooltip=%s`, attr, tooltip, tooltip)
+
+	if edge.Residual {
+		attr = attr + ` style="dotted"`
+	}
+
+	if hasNodelets {
+		// Separate children further if source has tags.
+		attr = attr + " minlen=2"
+	}
+
+	fmt.Fprintf(b, "N%d -> N%d [%s]\n", from, to, attr)
+}
+
+// dotColor returns a color for the given score (between -1.0 and
+// 1.0), with -1.0 colored red, 0.0 colored grey, and 1.0 colored
+// green.  If isBackground is true, then a light (low-saturation)
+// color is returned (suitable for use as a background color);
+// otherwise, a darker color is returned (suitable for use as a
+// foreground color).
+func dotColor(score float64, isBackground bool) string {
+	// A float between 0.0 and 1.0, indicating the extent to which
+	// colors should be shifted away from grey (to make positive and
+	// negative values easier to distinguish, and to make more use of
+	// the color range.)
+	const shift = 0.7
+
+	// Saturation and value (in hsv colorspace) for background colors.
+	const bgSaturation = 0.1
+	const bgValue = 0.93
+
+	// Saturation and value (in hsv colorspace) for foreground colors.
+	const fgSaturation = 1.0
+	const fgValue = 0.7
+
+	// Choose saturation and value based on isBackground.
+	var saturation float64
+	var value float64
+	if isBackground {
+		saturation = bgSaturation
+		value = bgValue
+	} else {
+		saturation = fgSaturation
+		value = fgValue
+	}
+
+	// Limit the score values to the range [-1.0, 1.0].
+	score = math.Max(-1.0, math.Min(1.0, score))
+
+	// Reduce saturation near score=0 (so it is colored grey, rather than yellow).
+	if math.Abs(score) < 0.2 {
+		saturation *= math.Abs(score) / 0.2
+	}
+
+	// Apply 'shift' to move scores away from 0.0 (grey).
+	if score > 0.0 {
+		score = math.Pow(score, (1.0 - shift))
+	}
+	if score < 0.0 {
+		score = -math.Pow(-score, (1.0 - shift))
+	}
+
+	var r, g, b float64 // red, green, blue
+	if score < 0.0 {
+		g = value
+		r = value * (1 + saturation*score)
+	} else {
+		r = value
+		g = value * (1 - saturation*score)
+	}
+	b = value * (1 - saturation)
+	return fmt.Sprintf("#%02x%02x%02x", uint8(r*255.0), uint8(g*255.0), uint8(b*255.0))
+}
+
+// percentage computes the percentage of total of a value, and encodes
+// it as a string. At least two digits of precision are printed.
+func percentage(value, total int64) string {
+	var ratio float64
+	if total != 0 {
+		ratio = math.Abs(float64(value)/float64(total)) * 100
+	}
+	switch {
+	case math.Abs(ratio) >= 99.95 && math.Abs(ratio) <= 100.05:
+		return "  100%"
+	case math.Abs(ratio) >= 1.0:
+		return fmt.Sprintf("%5.2f%%", ratio)
+	default:
+		return fmt.Sprintf("%5.2g%%", ratio)
+	}
+}
+
+func multilinePrintableName(info *NodeInfo) string {
+	infoCopy := *info
+	infoCopy.Name = strings.Replace(infoCopy.Name, "::", `\n`, -1)
+	infoCopy.Name = strings.Replace(infoCopy.Name, ".", `\n`, -1)
+	if infoCopy.File != "" {
+		infoCopy.File = filepath.Base(infoCopy.File)
+	}
+	return strings.Join(infoCopy.NameComponents(), `\n`) + `\n`
+}
+
+// collapsedTags trims and sorts a slice of tags.
+func collapsedTags(ts []*Tag, count int, flatTags bool) []*Tag {
+	ts = SortTags(ts, flatTags)
+	if len(ts) <= count {
+		return ts
+	}
+
+	tagGroups := make([][]*Tag, count)
+	for i, t := range (ts)[:count] {
+		tagGroups[i] = []*Tag{t}
+	}
+	for _, t := range (ts)[count:] {
+		g, d := 0, tagDistance(t, tagGroups[0][0])
+		for i := 1; i < count; i++ {
+			if nd := tagDistance(t, tagGroups[i][0]); nd < d {
+				g, d = i, nd
+			}
+		}
+		tagGroups[g] = append(tagGroups[g], t)
+	}
+
+	var nts []*Tag
+	for _, g := range tagGroups {
+		l, w, c := tagGroupLabel(g)
+		nts = append(nts, &Tag{
+			Name: l,
+			Flat: w,
+			Cum:  c,
+		})
+	}
+	return SortTags(nts, flatTags)
+}
+
+func tagDistance(t, u *Tag) float64 {
+	v, _ := measurement.Scale(u.Value, u.Unit, t.Unit)
+	if v < float64(t.Value) {
+		return float64(t.Value) - v
+	}
+	return v - float64(t.Value)
+}
+
+func tagGroupLabel(g []*Tag) (label string, flat, cum int64) {
+	if len(g) == 1 {
+		t := g[0]
+		return measurement.Label(t.Value, t.Unit), t.Flat, t.Cum
+	}
+	min := g[0]
+	max := g[0]
+	f := min.Flat
+	c := min.Cum
+	for _, t := range g[1:] {
+		if v, _ := measurement.Scale(t.Value, t.Unit, min.Unit); int64(v) < min.Value {
+			min = t
+		}
+		if v, _ := measurement.Scale(t.Value, t.Unit, max.Unit); int64(v) > max.Value {
+			max = t
+		}
+		f += t.Flat
+		c += t.Cum
+	}
+	return measurement.Label(min.Value, min.Unit) + ".." + measurement.Label(max.Value, max.Unit), f, c
+}
+
+func min64(a, b int64) int64 {
+	if a < b {
+		return a
+	}
+	return b
+}

src/internal/graph/dotgraph_test.go

+// 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.
+
+package graph
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+
+	"internal/proftest"
+)
+
+const path = "testdata/"
+
+func TestComposeWithStandardGraph(t *testing.T) {
+	g := baseGraph()
+	a, c := baseAttrsAndConfig()
+
+	var buf bytes.Buffer
+	ComposeDot(&buf, g, a, c)
+
+	want, err := ioutil.ReadFile(path + "compose1.dot")
+	if err != nil {
+		t.Fatalf("error reading test file: %v", err)
+	}
+
+	compareGraphs(t, buf.Bytes(), want)
+}
+
+func TestComposeWithNodeAttributesAndZeroFlat(t *testing.T) {
+	g := baseGraph()
+	a, c := baseAttrsAndConfig()
+
+	// Set NodeAttributes for Node 1.
+	a.Nodes[g.Nodes[0]] = &DotNodeAttributes{
+		Shape:       "folder",
+		Bold:        true,
+		Peripheries: 2,
+		URL:         "www.google.com",
+		Formatter: func(ni *NodeInfo) string {
+			return strings.ToUpper(ni.Name)
+		},
+	}
+
+	// Set Flat value to zero on Node 2.
+	g.Nodes[1].Flat = 0
+
+	var buf bytes.Buffer
+	ComposeDot(&buf, g, a, c)
+
+	want, err := ioutil.ReadFile(path + "compose2.dot")
+	if err != nil {
+		t.Fatalf("error reading test file: %v", err)
+	}
+
+	compareGraphs(t, buf.Bytes(), want)
+}
+
+func TestComposeWithTagsAndResidualEdge(t *testing.T) {
+	g := baseGraph()
+	a, c := baseAttrsAndConfig()
+
+	// Add tags to Node 1.
+	g.Nodes[0].LabelTags["a"] = &Tag{
+		Name: "tag1",
+		Cum:  10,
+		Flat: 10,
+	}
+	g.Nodes[0].NumericTags[""] = TagMap{
+		"b": &Tag{
+			Name: "tag2",
+			Cum:  20,
+			Flat: 20,
+			Unit: "ms",
+		},
+	}
+
+	// Set edge to be Residual.
+	g.Nodes[0].Out[g.Nodes[1]].Residual = true
+
+	var buf bytes.Buffer
+	ComposeDot(&buf, g, a, c)
+
+	want, err := ioutil.ReadFile(path + "compose3.dot")
+	if err != nil {
+		t.Fatalf("error reading test file: %v", err)
+	}
+
+	compareGraphs(t, buf.Bytes(), want)
+}
+
+func TestComposeWithNestedTags(t *testing.T) {
+	g := baseGraph()
+	a, c := baseAttrsAndConfig()
+
+	// Add tags to Node 1.
+	g.Nodes[0].LabelTags["tag1"] = &Tag{
+		Name: "tag1",
+		Cum:  10,
+		Flat: 10,
+	}
+	g.Nodes[0].NumericTags["tag1"] = TagMap{
+		"tag2": &Tag{
+			Name: "tag2",
+			Cum:  20,
+			Flat: 20,
+			Unit: "ms",
+		},
+	}
+
+	var buf bytes.Buffer
+	ComposeDot(&buf, g, a, c)
+
+	want, err := ioutil.ReadFile(path + "compose5.dot")
+	if err != nil {
+		t.Fatalf("error reading test file: %v", err)
+	}
+
+	compareGraphs(t, buf.Bytes(), want)
+}
+
+func TestComposeWithEmptyGraph(t *testing.T) {
+	g := &Graph{}
+	a, c := baseAttrsAndConfig()
+
+	var buf bytes.Buffer
+	ComposeDot(&buf, g, a, c)
+
+	want, err := ioutil.ReadFile(path + "compose4.dot")
+	if err != nil {
+		t.Fatalf("error reading test file: %v", err)
+	}
+
+	compareGraphs(t, buf.Bytes(), want)
+}
+
+func baseGraph() *Graph {
+	src := &Node{
+		Info:        NodeInfo{Name: "src"},
+		Flat:        10,
+		Cum:         25,
+		In:          make(EdgeMap),
+		Out:         make(EdgeMap),
+		LabelTags:   make(TagMap),
+		NumericTags: make(map[string]TagMap),
+	}
+	dest := &Node{
+		Info:        NodeInfo{Name: "dest"},
+		Flat:        15,
+		Cum:         25,
+		In:          make(EdgeMap),
+		Out:         make(EdgeMap),
+		LabelTags:   make(TagMap),
+		NumericTags: make(map[string]TagMap),
+	}
+	edge := &Edge{
+		Src:    src,
+		Dest:   dest,
+		Weight: 10,
+	}
+	src.Out[dest] = edge
+	src.In[src] = edge
+	return &Graph{
+		Nodes: Nodes{
+			src,
+			dest,
+		},
+	}
+}
+
+func baseAttrsAndConfig() (*DotAttributes, *DotConfig) {
+	a := &DotAttributes{
+		Nodes: make(map[*Node]*DotNodeAttributes),
+	}
+	c := &DotConfig{
+		Title:  "testtitle",
+		Labels: []string{"label1", "label2"},
+		Total:  100,
+		FormatValue: func(v int64) string {
+			return strconv.FormatInt(v, 10)
+		},
+	}
+	return a, c
+}
+
+func compareGraphs(t *testing.T, got, want []byte) {
+	if string(got) != string(want) {
+		d, err := proftest.Diff(got, want)
+		if err != nil {
+			t.Fatalf("error finding diff: %v", err)
+		}
+		t.Errorf("Compose incorrectly wrote %s", string(d))
+	}
+}
+
+func TestMultilinePrintableName(t *testing.T) {
+	ni := &NodeInfo{
+		Name:    "test1.test2::test3",
+		File:    "src/file.cc",
+		Address: 123,
+		Lineno:  999,
+	}
+
+	want := fmt.Sprintf(`%016x\ntest1\ntest2\ntest3\nfile.cc:999\n`, 123)
+	if got := multilinePrintableName(ni); got != want {
+		t.Errorf("multilinePrintableName(%#v) == %q, want %q", ni, got, want)
+	}
+}
+
+func TestTagCollapse(t *testing.T) {
+	tagSource := []*Tag{
+		{"12mb", "mb", 12, 100, 100},
+		{"1kb", "kb", 1, 1, 1},
+		{"1mb", "mb", 1, 1000, 1000},
+		{"2048mb", "mb", 2048, 1000, 1000},
+		{"1b", "b", 1, 100, 100},
+		{"2b", "b", 2, 100, 100},
+		{"7b", "b", 7, 100, 100},
+	}
+
+	tagWant := [][]*Tag{
+		[]*Tag{
+			{"1B..2GB", "", 0, 2401, 2401},
+		},
+		[]*Tag{
+			{"2GB", "", 0, 1000, 1000},
+			{"1B..12MB", "", 0, 1401, 1401},
+		},
+		[]*Tag{
+			{"2GB", "", 0, 1000, 1000},
+			{"12MB", "", 0, 100, 100},
+			{"1B..1MB", "", 0, 1301, 1301},
+		},
+		[]*Tag{
+			{"2GB", "", 0, 1000, 1000},
+			{"1MB", "", 0, 1000, 1000},
+			{"2B..1kB", "", 0, 201, 201},
+			{"1B", "", 0, 100, 100},
+			{"12MB", "", 0, 100, 100},
+		},
+	}
+
+	for _, tc := range tagWant {
+		var got, want []*Tag
+		got = collapsedTags(tagSource, len(tc), true)
+		want = SortTags(tc, true)
+
+		if !reflect.DeepEqual(got, want) {
+			t.Errorf("collapse to %d, got:\n%v\nwant:\n%v", len(tc), tagString(got), tagString(want))
+		}
+	}
+}
+
+func tagString(t []*Tag) string {
+	var ret []string
+	for _, s := range t {
+		ret = append(ret, fmt.Sprintln(s))
+	}
+	return strings.Join(ret, ":")
+}

src/internal/graph/graph.go

+// 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.
+
+// Package graph collects a set of samples into a directed graph.
+package graph
+
+import (
+	"fmt"
+	"math"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"profile"
+)
+
+// Graph summarizes a performance profile into a format that is
+// suitable for visualization.
+type Graph struct {
+	Nodes Nodes
+}
+
+// Options encodes the options for constructing a graph
+type Options struct {
+	SampleValue func(s []int64) int64      // Function to compute the value of a sample
+	FormatTag   func(int64, string) string // Function to format a sample tag value into a string
+	ObjNames    bool                       // Always preserve obj filename
+
+	CallTree     bool // Build a tree instead of a graph
+	DropNegative bool // Drop nodes with overall negative values
+
+	KeptNodes NodeSet // If non-nil, only use nodes in this set
+}
+
+// Nodes is an ordered collection of graph nodes.
+type Nodes []*Node
+
+// Node is an entry on a profiling report. It represents a unique
+// program location.
+type Node struct {
+	// Information associated to this entry.
+	Info NodeInfo
+
+	// values associated to this node.
+	// Flat is exclusive to this node, cum includes all descendents.
+	Flat, Cum int64
+
+	// in and out contains the nodes immediately reaching or reached by this nodes.
+	In, Out EdgeMap
+
+	// tags provide additional information about subsets of a sample.
+	LabelTags TagMap
+
+	// Numeric tags provide additional values for subsets of a sample.
+	// Numeric tags are optionally associated to a label tag. The key
+	// for NumericTags is the name of the LabelTag they are associated
+	// to, or "" for numeric tags not associated to a label tag.
+	NumericTags map[string]TagMap
+}
+
+// BumpWeight increases the weight of an edge between two nodes. If
+// there isn't such an edge one is created.
+func (n *Node) BumpWeight(to *Node, w int64, residual, inline bool) {
+	if n.Out[to] != to.In[n] {
+		panic(fmt.Errorf("asymmetric edges %v %v", *n, *to))
+	}
+
+	if e := n.Out[to]; e != nil {
+		e.Weight += w
+		if residual {
+			e.Residual = true
+		}
+		if !inline {
+			e.Inline = false
+		}
+		return
+	}
+
+	info := &Edge{Src: n, Dest: to, Weight: w, Residual: residual, Inline: inline}
+	n.Out[to] = info
+	to.In[n] = info
+}
+
+// NodeInfo contains the attributes for a node.
+type NodeInfo struct {
+	Name              string
+	OrigName          string
+	Address           uint64
+	File              string
+	StartLine, Lineno int
+	Objfile           string
+}
+
+// PrintableName calls the Node's Formatter function with a single space separator.
+func (i *NodeInfo) PrintableName() string {
+	return strings.Join(i.NameComponents(), " ")
+}
+
+// NameComponents returns the components of the printable name to be used for a node.
+func (i *NodeInfo) NameComponents() []string {
+	var name []string
+	if i.Address != 0 {
+		name = append(name, fmt.Sprintf("%016x", i.Address))
+	}
+	if fun := i.Name; fun != "" {
+		name = append(name, fun)
+	}
+
+	switch {
+	case i.Lineno != 0:
+		// User requested line numbers, provide what we have.
+		name = append(name, fmt.Sprintf("%s:%d", i.File, i.Lineno))
+	case i.File != "":
+		// User requested file name, provide it.
+		name = append(name, i.File)
+	case i.Name != "":
+		// User requested function name. It was already included.
+	case i.Objfile != "":
+		// Only binary name is available
+		name = append(name, "["+i.Objfile+"]")
+	default:
+		// Do not leave it empty if there is no information at all.
+		name = append(name, "<unknown>")
+	}
+	return name
+}
+
+// ExtendedNodeInfo extends the NodeInfo with a pointer to a parent node, to
+// identify nodes with identical information and different callers. This is
+// used when creating call trees.
+type ExtendedNodeInfo struct {
+	NodeInfo
+	parent *Node
+}
+
+// NodeMap maps from a node info struct to a node. It is used to merge
+// report entries with the same info.
+type NodeMap map[ExtendedNodeInfo]*Node
+
+// NodeSet maps is a collection of node info structs.
+type NodeSet map[NodeInfo]bool
+
+// FindOrInsertNode takes the info for a node and either returns a matching node
+// from the node map if one exists, or adds one to the map if one does not.
+// If parent is non-nil, return a match with the same parent.
+// If kept is non-nil, nodes are only added if they can be located on it.
+func (m NodeMap) FindOrInsertNode(info NodeInfo, parent *Node, kept NodeSet) *Node {
+	if kept != nil && !kept[info] {
+		return nil
+	}
+
+	extendedInfo := ExtendedNodeInfo{
+		info,
+		parent,
+	}
+
+	if n := m[extendedInfo]; n != nil {
+		return n
+	}
+
+	n := &Node{
+		Info:        info,
+		In:          make(EdgeMap),
+		Out:         make(EdgeMap),
+		LabelTags:   make(TagMap),
+		NumericTags: make(map[string]TagMap),
+	}
+	m[extendedInfo] = n
+	return n
+}
+
+// EdgeMap is used to represent the incoming/outgoing edges from a node.
+type EdgeMap map[*Node]*Edge
+
+// Edge contains any attributes to be represented about edges in a graph.
+type Edge struct {
+	Src, Dest *Node
+	// The summary weight of the edge
+	Weight int64
+	// residual edges connect nodes that were connected through a
+	// separate node, which has been removed from the report.
+	Residual bool
+	// An inline edge represents a call that was inlined into the caller.
+	Inline bool
+}
+
+// Tag represent sample annotations
+type Tag struct {
+	Name  string
+	Unit  string // Describe the value, "" for non-numeric tags
+	Value int64
+	Flat  int64
+	Cum   int64
+}
+
+// TagMap is a collection of tags, classified by their name.
+type TagMap map[string]*Tag
+
+// SortTags sorts a slice of tags based on their weight.
+func SortTags(t []*Tag, flat bool) []*Tag {
+	ts := tags{t, flat}
+	sort.Sort(ts)
+	return ts.t
+}
+
+// New summarizes performance data from a profile into a graph.
+func New(prof *profile.Profile, o *Options) (g *Graph) {
+	locations := NewLocInfo(prof, o.ObjNames)
+	nm := make(NodeMap)
+	for _, sample := range prof.Sample {
+		if sample.Location == nil {
+			continue
+		}
+
+		// Construct list of node names for sample.
+		// Keep track of the index on the Sample for each frame,
+		// to determine inlining status.
+
+		var stack []NodeInfo
+		var locIndex []int
+		for i, loc := range sample.Location {
+			id := loc.ID
+			stack = append(stack, locations[id]...)
+			for _ = range locations[id] {
+				locIndex = append(locIndex, i)
+			}
+		}
+
+		weight := o.SampleValue(sample.Value)
+		seenEdge := make(map[*Node]map[*Node]bool)
+		var nn *Node
+		nlocIndex := -1
+		residual := false
+		// Walk top-down over the frames in a sample, keeping track
+		// of the current parent if we're building a tree.
+		for i := len(stack); i > 0; i-- {
+			var parent *Node
+			if o.CallTree {
+				parent = nn
+			}
+			n := nm.FindOrInsertNode(stack[i-1], parent, o.KeptNodes)
+			if n == nil {
+				residual = true
+				continue
+			}
+			// Add flat weight to leaf node.
+			if i == 1 {
+				n.addSample(sample, weight, o.FormatTag, true)
+			}
+			// Add cum weight to all nodes in stack, avoiding double counting.
+			if seenEdge[n] == nil {
+				seenEdge[n] = make(map[*Node]bool)
+				n.addSample(sample, weight, o.FormatTag, false)
+			}
+			// Update edge weights for all edges in stack, avoiding double counting.
+			if nn != nil && n != nn && !seenEdge[n][nn] {
+				seenEdge[n][nn] = true
+				// This is an inlined edge if the caller and the callee
+				// correspond to the same entry in the sample.
+				nn.BumpWeight(n, weight, residual, locIndex[i-1] == nlocIndex)
+			}
+			nn = n
+			nlocIndex = locIndex[i-1]
+			residual = false
+		}
+	}
+
+	// Collect nodes into a graph.
+	ns := make(Nodes, 0, len(nm))
+	for _, n := range nm {
+		if o.DropNegative && isNegative(n) {
+			continue
+		}
+		ns = append(ns, n)
+	}
+
+	return &Graph{ns}
+}
+
+// isNegative returns true if the node is considered as "negative" for the
+// purposes of drop_negative.
+func isNegative(n *Node) bool {
+	switch {
+	case n.Flat < 0:
+		return true
+	case n.Flat == 0 && n.Cum < 0:
+		return true
+	default:
+		return false
+	}
+}
+
+// NewLocInfo creates a slice of formatted names for a location.
+func NewLocInfo(prof *profile.Profile, keepBinary bool) map[uint64][]NodeInfo {
+	locations := make(map[uint64][]NodeInfo)
+
+	for _, l := range prof.Location {
+		var objfile string
+
+		if m := l.Mapping; m != nil {
+			objfile = filepath.Base(m.File)
+		}
+
+		if len(l.Line) == 0 {
+			locations[l.ID] = []NodeInfo{
+				{
+					Address: l.Address,
+					Objfile: objfile,
+				},
+			}
+			continue
+		}
+		var info []NodeInfo
+		for _, line := range l.Line {
+			ni := NodeInfo{
+				Address: l.Address,
+				Lineno:  int(line.Line),
+			}
+
+			if line.Function != nil {
+				ni.Name = line.Function.Name
+				ni.OrigName = line.Function.SystemName
+				ni.File = line.Function.Filename
+				ni.StartLine = int(line.Function.StartLine)
+			}
+			if keepBinary || line.Function == nil {
+				ni.Objfile = objfile
+			}
+			info = append(info, ni)
+		}
+		locations[l.ID] = info
+	}
+	return locations
+}
+
+type tags struct {
+	t    []*Tag
+	flat bool
+}
+
+func (t tags) Len() int      { return len(t.t) }
+func (t tags) Swap(i, j int) { t.t[i], t.t[j] = t.t[j], t.t[i] }
+func (t tags) Less(i, j int) bool {
+	if !t.flat {
+		if t.t[i].Cum != t.t[j].Cum {
+			return abs64(t.t[i].Cum) > abs64(t.t[j].Cum)
+		}
+	}
+	if t.t[i].Flat != t.t[j].Flat {
+		return abs64(t.t[i].Flat) > abs64(t.t[j].Flat)
+	}
+	return t.t[i].Name < t.t[j].Name
+}
+
+// Sum adds the Flat and sum values on a report.
+func (ns Nodes) Sum() (flat int64, cum int64) {
+	for _, n := range ns {
+		flat += n.Flat
+		cum += n.Cum
+	}
+	return
+}
+
+func (n *Node) addSample(s *profile.Sample, value int64, format func(int64, string) string, flat bool) {
+	// Update sample value
+	if flat {
+		n.Flat += value
+	} else {
+		n.Cum += value
+	}
+
+	// Add string tags
+	var labels []string
+	for key, vals := range s.Label {
+		for _, v := range vals {
+			labels = append(labels, key+":"+v)
+		}
+	}
+	var joinedLabels string
+	if len(labels) > 0 {
+		sort.Strings(labels)
+		joinedLabels = strings.Join(labels, `\n`)
+		t := n.LabelTags.findOrAddTag(joinedLabels, "", 0)
+		if flat {
+			t.Flat += value
+		} else {
+			t.Cum += value
+		}
+	}
+
+	numericTags := n.NumericTags[joinedLabels]
+	if numericTags == nil {
+		numericTags = TagMap{}
+		n.NumericTags[joinedLabels] = numericTags
+	}
+	// Add numeric tags
+	for key, nvals := range s.NumLabel {
+		for _, v := range nvals {
+			var label string
+			if format != nil {
+				label = format(v, key)
+			} else {
+				label = fmt.Sprintf("%d", v)
+			}
+			t := numericTags.findOrAddTag(label, key, v)
+			if flat {
+				t.Flat += value
+			} else {
+				t.Cum += value
+			}
+		}
+	}
+}
+
+func (m TagMap) findOrAddTag(label, unit string, value int64) *Tag {
+	l := m[label]
+	if l == nil {
+		l = &Tag{
+			Name:  label,
+			Unit:  unit,
+			Value: value,
+		}
+		m[label] = l
+	}
+	return l
+}
+
+// String returns a text representation of a graph, for debugging purposes.
+func (g *Graph) String() string {
+	var s []string
+
+	nodeIndex := make(map[*Node]int, len(g.Nodes))
+
+	for i, n := range g.Nodes {
+		nodeIndex[n] = i + 1
+	}
+
+	for i, n := range g.Nodes {
+		name := n.Info.PrintableName()
+		var in, out []int
+
+		for _, from := range n.In {
+			in = append(in, nodeIndex[from.Src])
+		}
+		for _, to := range n.Out {
+			out = append(out, nodeIndex[to.Dest])
+		}
+		s = append(s, fmt.Sprintf("%d: %s[flat=%d cum=%d] %x -> %v ", i+1, name, n.Flat, n.Cum, in, out))
+	}
+	return strings.Join(s, "\n")
+}
+
+// DiscardLowFrequencyNodes returns a set of the nodes at or over a
+// specific cum value cutoff.
+func (g *Graph) DiscardLowFrequencyNodes(nodeCutoff int64) NodeSet {
+	return makeNodeSet(g.Nodes, nodeCutoff)
+}
+
+func makeNodeSet(nodes Nodes, nodeCutoff int64) NodeSet {
+	kept := make(NodeSet, len(nodes))
+	for _, n := range nodes {
+		if abs64(n.Cum) < nodeCutoff {
+			continue
+		}
+		kept[n.Info] = true
+	}
+	return kept
+}
+
+// TrimLowFrequencyTags removes tags that have less than
+// the specified weight.
+func (g *Graph) TrimLowFrequencyTags(tagCutoff int64) {
+	// Remove nodes with value <= total*nodeFraction
+	for _, n := range g.Nodes {
+		n.LabelTags = trimLowFreqTags(n.LabelTags, tagCutoff)
+		for s, nt := range n.NumericTags {
+			n.NumericTags[s] = trimLowFreqTags(nt, tagCutoff)
+		}
+	}
+}
+
+func trimLowFreqTags(tags TagMap, minValue int64) TagMap {
+	kept := TagMap{}
+	for s, t := range tags {
+		if abs64(t.Flat) >= minValue || abs64(t.Cum) >= minValue {
+			kept[s] = t
+		}
+	}
+	return kept
+}
+
+// TrimLowFrequencyEdges removes edges that have less than
+// the specified weight. Returns the number of edges removed
+func (g *Graph) TrimLowFrequencyEdges(edgeCutoff int64) int {
+	var droppedEdges int
+	for _, n := range g.Nodes {
+		for src, e := range n.In {
+			if abs64(e.Weight) < edgeCutoff {
+				delete(n.In, src)
+				delete(src.Out, n)
+				droppedEdges++
+			}
+		}
+	}
+	return droppedEdges
+}
+
+// SortNodes sorts the nodes in a graph based on a specific heuristic.
+func (g *Graph) SortNodes(cum bool, visualMode bool) {
+	// Sort nodes based on requested mode
+	switch {
+	case visualMode:
+		// Specialized sort to produce a more visually-interesting graph
+		g.Nodes.Sort(EntropyOrder)
+	case cum:
+		g.Nodes.Sort(CumNameOrder)
+	default:
+		g.Nodes.Sort(FlatNameOrder)
+	}
+}
+
+// SelectTopNodes returns a set of the top maxNodes nodes in a graph.
+func (g *Graph) SelectTopNodes(maxNodes int, visualMode bool) NodeSet {
+	if maxNodes > 0 {
+		if visualMode {
+			var count int
+			// If generating a visual graph, count tags as nodes. Update
+			// maxNodes to account for them.
+			for i, n := range g.Nodes {
+				if count += countTags(n) + 1; count >= maxNodes {
+					maxNodes = i + 1
+					break
+				}
+			}
+		}
+	}
+	if maxNodes > len(g.Nodes) {
+		maxNodes = len(g.Nodes)
+	}
+	return makeNodeSet(g.Nodes[:maxNodes], 0)
+}
+
+// countTags counts the tags with flat count. This underestimates the
+// number of tags being displayed, but in practice is close enough.
+func countTags(n *Node) int {
+	count := 0
+	for _, e := range n.LabelTags {
+		if e.Flat != 0 {
+			count++
+		}
+	}
+	for _, t := range n.NumericTags {
+		for _, e := range t {
+			if e.Flat != 0 {
+				count++
+			}
+		}
+	}
+	return count
+}
+
+// countEdges counts the number of edges below the specified cutoff.
+func countEdges(el EdgeMap, cutoff int64) int {
+	count := 0
+	for _, e := range el {
+		if e.Weight > cutoff {
+			count++
+		}
+	}
+	return count
+}
+
+// RemoveRedundantEdges removes residual edges if the destination can
+// be reached through another path. This is done to simplify the graph
+// while preserving connectivity.
+func (g *Graph) RemoveRedundantEdges() {
+	// Walk the nodes and outgoing edges in reverse order to prefer
+	// removing edges with the lowest weight.
+	for i := len(g.Nodes); i > 0; i-- {
+		n := g.Nodes[i-1]
+		in := n.In.Sort()
+		for j := len(in); j > 0; j-- {
+			e := in[j-1]
+			if !e.Residual {
+				// Do not remove edges heavier than a non-residual edge, to
+				// avoid potential confusion.
+				break
+			}
+			if isRedundant(e) {
+				delete(e.Src.Out, e.Dest)
+				delete(e.Dest.In, e.Src)
+			}
+		}
+	}
+}
+
+// isRedundant determines if an edge can be removed without impacting
+// connectivity of the whole graph. This is implemented by checking if the
+// nodes have a common ancestor after removing the edge.
+func isRedundant(e *Edge) bool {
+	destPred := predecessors(e, e.Dest)
+	if len(destPred) == 1 {
+		return false
+	}
+	srcPred := predecessors(e, e.Src)
+
+	for n := range srcPred {
+		if destPred[n] && n != e.Dest {
+			return true
+		}
+	}
+	return false
+}
+
+// predecessors collects all the predecessors to node n, excluding edge e.
+func predecessors(e *Edge, n *Node) map[*Node]bool {
+	seen := map[*Node]bool{n: true}
+	queue := []*Node{n}
+	for len(queue) > 0 {
+		n := queue[0]
+		queue = queue[1:]
+		for _, ie := range n.In {
+			if e == ie || seen[ie.Src] {
+				continue
+			}
+			seen[ie.Src] = true
+			queue = append(queue, ie.Src)
+		}
+	}
+	return seen
+}
+
+// nodeSorter is a mechanism used to allow a report to be sorted
+// in different ways.
+type nodeSorter struct {
+	rs   Nodes
+	less func(l, r *Node) bool
+}
+
+func (s nodeSorter) Len() int           { return len(s.rs) }
+func (s nodeSorter) Swap(i, j int)      { s.rs[i], s.rs[j] = s.rs[j], s.rs[i] }
+func (s nodeSorter) Less(i, j int) bool { return s.less(s.rs[i], s.rs[j]) }
+
+// Sort reorders a slice of nodes based on the specified ordering
+// criteria. The result is sorted in decreasing order for (absolute)
+// numeric quantities, alphabetically for text, and increasing for
+// addresses.
+func (ns Nodes) Sort(o NodeOrder) error {
+	var s nodeSorter
+
+	switch o {
+	case FlatNameOrder:
+		s = nodeSorter{ns,
+			func(l, r *Node) bool {
+				if iv, jv := l.Flat, r.Flat; iv != jv {
+					return abs64(iv) > abs64(jv)
+				}
+				if l.Info.PrintableName() != r.Info.PrintableName() {
+					return l.Info.PrintableName() < r.Info.PrintableName()
+				}
+				iv, jv := l.Cum, r.Cum
+				return abs64(iv) > abs64(jv)
+			},
+		}
+	case FlatCumNameOrder:
+		s = nodeSorter{ns,
+			func(l, r *Node) bool {
+				if iv, jv := l.Flat, r.Flat; iv != jv {
+					return abs64(iv) > abs64(jv)
+				}
+				if iv, jv := l.Cum, r.Cum; iv != jv {
+					return abs64(iv) > abs64(jv)
+				}
+				return l.Info.PrintableName() < r.Info.PrintableName()
+			},
+		}
+	case NameOrder:
+		s = nodeSorter{ns,
+			func(l, r *Node) bool {
+				return l.Info.Name < r.Info.Name
+			},
+		}
+	case FileOrder:
+		s = nodeSorter{ns,
+			func(l, r *Node) bool {
+				return l.Info.File < r.Info.File
+			},
+		}
+	case AddressOrder:
+		s = nodeSorter{ns,
+			func(l, r *Node) bool {
+				return l.Info.Address < r.Info.Address
+			},
+		}
+	case CumNameOrder, EntropyOrder:
+		// Hold scoring for score-based ordering
+		var score map[*Node]int64
+		scoreOrder := func(l, r *Node) bool {
+			if is, js := score[l], score[r]; is != js {
+				return abs64(is) > abs64(js)
+			}
+			if l.Info.PrintableName() != r.Info.PrintableName() {
+				return l.Info.PrintableName() < r.Info.PrintableName()
+			}
+			return abs64(l.Flat) > abs64(r.Flat)
+		}
+
+		switch o {
+		case CumNameOrder:
+			score = make(map[*Node]int64, len(ns))
+			for _, n := range ns {
+				score[n] = n.Cum
+			}
+			s = nodeSorter{ns, scoreOrder}
+		case EntropyOrder:
+			score = make(map[*Node]int64, len(ns))
+			for _, n := range ns {
+				score[n] = entropyScore(n)
+			}
+			s = nodeSorter{ns, scoreOrder}
+		}
+	default:
+		return fmt.Errorf("report: unrecognized sort ordering: %d", o)
+	}
+	sort.Sort(s)
+	return nil
+}
+
+// entropyScore computes a score for a node representing how important
+// it is to include this node on a graph visualization. It is used to
+// sort the nodes and select which ones to display if we have more
+// nodes than desired in the graph. This number is computed by looking
+// at the flat and cum weights of the node and the incoming/outgoing
+// edges. The fundamental idea is to penalize nodes that have a simple
+// fallthrough from their incoming to the outgoing edge.
+func entropyScore(n *Node) int64 {
+	score := float64(0)
+
+	if len(n.In) == 0 {
+		score++ // Favor entry nodes
+	} else {
+		score += edgeEntropyScore(n, n.In, 0)
+	}
+
+	if len(n.Out) == 0 {
+		score++ // Favor leaf nodes
+	} else {
+		score += edgeEntropyScore(n, n.Out, n.Flat)
+	}
+
+	return int64(score*float64(n.Cum)) + n.Flat
+}
+
+// edgeEntropyScore computes the entropy value for a set of edges
+// coming in or out of a node. Entropy (as defined in information
+// theory) refers to the amount of information encoded by the set of
+// edges. A set of edges that have a more interesting distribution of
+// samples gets a higher score.
+func edgeEntropyScore(n *Node, edges EdgeMap, self int64) float64 {
+	score := float64(0)
+	total := self
+	for _, e := range edges {
+		if e.Weight > 0 {
+			total += abs64(e.Weight)
+		}
+	}
+	if total != 0 {
+		for _, e := range edges {
+			frac := float64(abs64(e.Weight)) / float64(total)
+			score += -frac * math.Log2(frac)
+		}
+		if self > 0 {
+			frac := float64(abs64(self)) / float64(total)
+			score += -frac * math.Log2(frac)
+		}
+	}
+	return score
+}
+
+// NodeOrder sets the ordering for a Sort operation
+type NodeOrder int
+
+// Sorting options for node sort.
+const (
+	FlatNameOrder NodeOrder = iota
+	FlatCumNameOrder
+	CumNameOrder
+	NameOrder
+	FileOrder
+	AddressOrder
+	EntropyOrder
+)
+
+// Sort returns a slice of the edges in the map, in a consistent
+// order. The sort order is first based on the edge weight
+// (higher-to-lower) and then by the node names to avoid flakiness.
+func (e EdgeMap) Sort() []*Edge {
+	el := make(edgeList, 0, len(e))
+	for _, w := range e {
+		el = append(el, w)
+	}
+
+	sort.Sort(el)
+	return el
+}
+
+// Sum returns the total weight for a set of nodes.
+func (e EdgeMap) Sum() int64 {
+	var ret int64
+	for _, edge := range e {
+		ret += edge.Weight
+	}
+	return ret
+}
+
+type edgeList []*Edge
+
+func (el edgeList) Len() int {
+	return len(el)
+}
+
+func (el edgeList) Less(i, j int) bool {
+	if el[i].Weight != el[j].Weight {
+		return abs64(el[i].Weight) > abs64(el[j].Weight)
+	}
+
+	from1 := el[i].Src.Info.PrintableName()
+	from2 := el[j].Src.Info.PrintableName()
+	if from1 != from2 {
+		return from1 < from2
+	}
+
+	to1 := el[i].Dest.Info.PrintableName()
+	to2 := el[j].Dest.Info.PrintableName()
+
+	return to1 < to2
+}
+
+func (el edgeList) Swap(i, j int) {
+	el[i], el[j] = el[j], el[i]
+}
+
+func abs64(i int64) int64 {
+	if i < 0 {
+		return -i
+	}
+	return i
+}

src/internal/graph/testdata/compose1.dot

+digraph "testtitle" {
+node [style=filled fillcolor="#f8f8f8"]
+subgraph cluster_L { "label1" [shape=box fontsize=16 label="label1\llabel2\l"] }
+N1 [label="src\n10 (10.00%)\nof 25 (25.00%)" fontsize=22 shape=box tooltip="src (25)" color="#b23c00" fillcolor="#edddd5"]
+N2 [label="dest\n15 (15.00%)\nof 25 (25.00%)" fontsize=24 shape=box tooltip="dest (25)" color="#b23c00" fillcolor="#edddd5"]
+N1 -> N2 [label=" 10" weight=11 color="#b28559" tooltip="src -> dest (10)" labeltooltip="src -> dest (10)"]
+}

src/internal/graph/testdata/compose2.dot

+digraph "testtitle" {
+node [style=filled fillcolor="#f8f8f8"]
+subgraph cluster_L { "label1" [shape=box fontsize=16 label="label1\llabel2\l"] }
+N1 [label="SRC10 (10.00%)\nof 25 (25.00%)" fontsize=24 shape=folder tooltip="src (25)" color="#b23c00" fillcolor="#edddd5" style="bold,filled" peripheries=2 URL="www.google.com" target="_blank"]
+N2 [label="dest\n0 of 25 (25.00%)" fontsize=8 shape=box tooltip="dest (25)" color="#b23c00" fillcolor="#edddd5"]
+N1 -> N2 [label=" 10" weight=11 color="#b28559" tooltip="src -> dest (10)" labeltooltip="src -> dest (10)"]
+}

src/internal/graph/testdata/compose3.dot

+digraph "testtitle" {
+node [style=filled fillcolor="#f8f8f8"]
+subgraph cluster_L { "label1" [shape=box fontsize=16 label="label1\llabel2\l"] }
+N1 [label="src\n10 (10.00%)\nof 25 (25.00%)" fontsize=22 shape=box tooltip="src (25)" color="#b23c00" fillcolor="#edddd5"]
+N1_0 [label = "tag1" fontsize=8 shape=box3d tooltip="10"]
+N1 -> N1_0 [label=" 10" weight=100 tooltip="10" labeltooltip="10"]
+NN1_0 [label = "tag2" fontsize=8 shape=box3d tooltip="20"]
+N1 -> NN1_0 [label=" 20" weight=100 tooltip="20" labeltooltip="20"]
+N2 [label="dest\n15 (15.00%)\nof 25 (25.00%)" fontsize=24 shape=box tooltip="dest (25)" color="#b23c00" fillcolor="#edddd5"]
+N1 -> N2 [label=" 10" weight=11 color="#b28559" tooltip="src ... dest (10)" labeltooltip="src ... dest (10)" style="dotted" minlen=2]
+}

src/internal/graph/testdata/compose4.dot

+digraph "testtitle" {
+node [style=filled fillcolor="#f8f8f8"]
+subgraph cluster_L { "label1" [shape=box fontsize=16 label="label1\llabel2\l"] }
+}

src/internal/graph/testdata/compose5.dot

+digraph "testtitle" {
+node [style=filled fillcolor="#f8f8f8"]
+subgraph cluster_L { "label1" [shape=box fontsize=16 label="label1\llabel2\l"] }
+N1 [label="src\n10 (10.00%)\nof 25 (25.00%)" fontsize=22 shape=box tooltip="src (25)" color="#b23c00" fillcolor="#edddd5"]
+N1_0 [label = "tag1" fontsize=8 shape=box3d tooltip="10"]
+N1 -> N1_0 [label=" 10" weight=100 tooltip="10" labeltooltip="10"]
+NN1_0_0 [label = "tag2" fontsize=8 shape=box3d tooltip="20"]
+N1_0 -> NN1_0_0 [label=" 20" weight=100 tooltip="20" labeltooltip="20"]
+N2 [label="dest\n15 (15.00%)\nof 25 (25.00%)" fontsize=24 shape=box tooltip="dest (25)" color="#b23c00" fillcolor="#edddd5"]
+N1 -> N2 [label=" 10" weight=11 color="#b28559" tooltip="src -> dest (10)" labeltooltip="src -> dest (10)" minlen=2]
+}

src/internal/measurement/measurement.go

+// 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.
+
+// Package measurement export utility functions to manipulate/format performance profile sample values.
+package measurement
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"profile"
+)
+
+// ScaleProfiles updates the units in a set of profiles to make them
+// compatible. It scales the profiles to the smallest unit to preserve
+// data.
+func ScaleProfiles(profiles []*profile.Profile) error {
+	if len(profiles) == 0 {
+		return nil
+	}
+	periodTypes := make([]*profile.ValueType, 0, len(profiles))
+	for _, p := range profiles {
+		if p.PeriodType != nil {
+			periodTypes = append(periodTypes, p.PeriodType)
+		}
+	}
+	periodType, err := CommonValueType(periodTypes)
+	if err != nil {
+		return fmt.Errorf("period type: %v", err)
+	}
+
+	// Identify common sample types
+	numSampleTypes := len(profiles[0].SampleType)
+	for _, p := range profiles[1:] {
+		if numSampleTypes != len(p.SampleType) {
+			return fmt.Errorf("inconsistent samples type count: %d != %d", numSampleTypes, len(p.SampleType))
+		}
+	}
+	sampleType := make([]*profile.ValueType, numSampleTypes)
+	for i := 0; i < numSampleTypes; i++ {
+		sampleTypes := make([]*profile.ValueType, len(profiles))
+		for j, p := range profiles {
+			sampleTypes[j] = p.SampleType[i]
+		}
+		sampleType[i], err = CommonValueType(sampleTypes)
+		if err != nil {
+			return fmt.Errorf("sample types: %v", err)
+		}
+	}
+
+	for _, p := range profiles {
+		if p.PeriodType != nil && periodType != nil {
+			period, _ := Scale(p.Period, p.PeriodType.Unit, periodType.Unit)
+			p.Period, p.PeriodType.Unit = int64(period), periodType.Unit
+		}
+		ratios := make([]float64, len(p.SampleType))
+		for i, st := range p.SampleType {
+			if sampleType[i] == nil {
+				ratios[i] = 1
+				continue
+			}
+			ratios[i], _ = Scale(1, st.Unit, sampleType[i].Unit)
+			p.SampleType[i].Unit = sampleType[i].Unit
+		}
+		if err := p.ScaleN(ratios); err != nil {
+			return fmt.Errorf("scale: %v", err)
+		}
+	}
+	return nil
+}
+
+// CommonValueType returns the finest type from a set of compatible
+// types.
+func CommonValueType(ts []*profile.ValueType) (*profile.ValueType, error) {
+	if len(ts) <= 1 {
+		return nil, nil
+	}
+	minType := ts[0]
+	for _, t := range ts[1:] {
+		if !compatibleValueTypes(minType, t) {
+			return nil, fmt.Errorf("incompatible types: %v %v", *minType, *t)
+		}
+		if ratio, _ := Scale(1, t.Unit, minType.Unit); ratio < 1 {
+			minType = t
+		}
+	}
+	rcopy := *minType
+	return &rcopy, nil
+}
+
+func compatibleValueTypes(v1, v2 *profile.ValueType) bool {
+	if v1 == nil || v2 == nil {
+		return true // No grounds to disqualify.
+	}
+	// Remove trailing 's' to permit minor mismatches.
+	if t1, t2 := strings.TrimSuffix(v1.Type, "s"), strings.TrimSuffix(v2.Type, "s"); t1 != t2 {
+		return false
+	}
+
+	return v1.Unit == v2.Unit ||
+		(isTimeUnit(v1.Unit) && isTimeUnit(v2.Unit)) ||
+		(isMemoryUnit(v1.Unit) && isMemoryUnit(v2.Unit))
+}
+
+// Scale a measurement from an unit to a different unit and returns
+// the scaled value and the target unit.  The returned target unit
+// will be empty if uninteresting (could be skipped).
+func Scale(value int64, fromUnit, toUnit string) (float64, string) {
+	// Avoid infinite recursion on overflow.
+	if value < 0 && -value > 0 {
+		v, u := Scale(-value, fromUnit, toUnit)
+		return -v, u
+	}
+	if m, u, ok := memoryLabel(value, fromUnit, toUnit); ok {
+		return m, u
+	}
+	if t, u, ok := timeLabel(value, fromUnit, toUnit); ok {
+		return t, u
+	}
+	// Skip non-interesting units.
+	switch toUnit {
+	case "count", "sample", "unit", "minimum", "auto":
+		return float64(value), ""
+	default:
+		return float64(value), toUnit
+	}
+}
+
+// Label returns the label used to describe a certain measurement.
+func Label(value int64, unit string) string {
+	return ScaledLabel(value, unit, "auto")
+}
+
+// ScaledLabel scales the passed-in measurement (if necessary) and
+// returns the label used to describe a float measurement.
+func ScaledLabel(value int64, fromUnit, toUnit string) string {
+	v, u := Scale(value, fromUnit, toUnit)
+	sv := strings.TrimSuffix(fmt.Sprintf("%.2f", v), ".00")
+	if sv == "0" || sv == "-0" {
+		return "0"
+	}
+	return sv + u
+}
+
+// isMemoryUnit returns whether a name is recognized as a memory size
+// unit.
+func isMemoryUnit(unit string) bool {
+	switch strings.TrimSuffix(strings.ToLower(unit), "s") {
+	case "byte", "b", "kilobyte", "kb", "megabyte", "mb", "gigabyte", "gb":
+		return true
+	}
+	return false
+}
+
+func memoryLabel(value int64, fromUnit, toUnit string) (v float64, u string, ok bool) {
+	fromUnit = strings.TrimSuffix(strings.ToLower(fromUnit), "s")
+	toUnit = strings.TrimSuffix(strings.ToLower(toUnit), "s")
+
+	switch fromUnit {
+	case "byte", "b":
+	case "kilobyte", "kb":
+		value *= 1024
+	case "megabyte", "mb":
+		value *= 1024 * 1024
+	case "gigabyte", "gb":
+		value *= 1024 * 1024 * 1024
+	default:
+		return 0, "", false
+	}
+
+	if toUnit == "minimum" || toUnit == "auto" {
+		switch {
+		case value < 1024:
+			toUnit = "b"
+		case value < 1024*1024:
+			toUnit = "kb"
+		case value < 1024*1024*1024:
+			toUnit = "mb"
+		default:
+			toUnit = "gb"
+		}
+	}
+
+	var output float64
+	switch toUnit {
+	default:
+		output, toUnit = float64(value), "B"
+	case "kb", "kbyte", "kilobyte":
+		output, toUnit = float64(value)/1024, "kB"
+	case "mb", "mbyte", "megabyte":
+		output, toUnit = float64(value)/(1024*1024), "MB"
+	case "gb", "gbyte", "gigabyte":
+		output, toUnit = float64(value)/(1024*1024*1024), "GB"
+	}
+	return output, toUnit, true
+}
+
+// isTimeUnit returns whether a name is recognized as a time unit.
+func isTimeUnit(unit string) bool {
+	unit = strings.ToLower(unit)
+	if len(unit) > 2 {
+		unit = strings.TrimSuffix(unit, "s")
+	}
+
+	switch unit {
+	case "nanosecond", "ns", "microsecond", "millisecond", "ms", "s", "second", "sec", "hr", "day", "week", "year":
+		return true
+	}
+	return false
+}
+
+func timeLabel(value int64, fromUnit, toUnit string) (v float64, u string, ok bool) {
+	fromUnit = strings.ToLower(fromUnit)
+	if len(fromUnit) > 2 {
+		fromUnit = strings.TrimSuffix(fromUnit, "s")
+	}
+
+	toUnit = strings.ToLower(toUnit)
+	if len(toUnit) > 2 {
+		toUnit = strings.TrimSuffix(toUnit, "s")
+	}
+
+	var d time.Duration
+	switch fromUnit {
+	case "nanosecond", "ns":
+		d = time.Duration(value) * time.Nanosecond
+	case "microsecond":
+		d = time.Duration(value) * time.Microsecond
+	case "millisecond", "ms":
+		d = time.Duration(value) * time.Millisecond
+	case "second", "sec", "s":
+		d = time.Duration(value) * time.Second
+	case "cycle":
+		return float64(value), "", true
+	default:
+		return 0, "", false
+	}
+
+	if toUnit == "minimum" || toUnit == "auto" {
+		switch {
+		case d < 1*time.Microsecond:
+			toUnit = "ns"
+		case d < 1*time.Millisecond:
+			toUnit = "us"
+		case d < 1*time.Second:
+			toUnit = "ms"
+		case d < 1*time.Minute:
+			toUnit = "sec"
+		case d < 1*time.Hour:
+			toUnit = "min"
+		case d < 24*time.Hour:
+			toUnit = "hour"
+		case d < 15*24*time.Hour:
+			toUnit = "day"
+		case d < 120*24*time.Hour:
+			toUnit = "week"
+		default:
+			toUnit = "year"
+		}
+	}
+
+	var output float64
+	dd := float64(d)
+	switch toUnit {
+	case "ns", "nanosecond":
+		output, toUnit = dd/float64(time.Nanosecond), "ns"
+	case "us", "microsecond":
+		output, toUnit = dd/float64(time.Microsecond), "us"
+	case "ms", "millisecond":
+		output, toUnit = dd/float64(time.Millisecond), "ms"
+	case "min", "minute":
+		output, toUnit = dd/float64(time.Minute), "mins"
+	case "hour", "hr":
+		output, toUnit = dd/float64(time.Hour), "hrs"
+	case "day":
+		output, toUnit = dd/float64(24*time.Hour), "days"
+	case "week", "wk":
+		output, toUnit = dd/float64(7*24*time.Hour), "wks"
+	case "year", "yr":
+		output, toUnit = dd/float64(365*7*24*time.Hour), "yrs"
+	default:
+		fallthrough
+	case "sec", "second", "s":
+		output, toUnit = dd/float64(time.Second), "s"
+	}
+	return output, toUnit, true
+}

src/internal/plugin/plugin.go

+// 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.
+
+// Package plugin defines the plugin implementations that the main pprof driver requires.
+package plugin
+
+import (
+	"io"
+	"regexp"
+	"time"
+
+	"profile"
+)
+
+// Options groups all the optional plugins into pprof.
+type Options struct {
+	Writer  Writer
+	Flagset FlagSet
+	Fetch   Fetcher
+	Sym     Symbolizer
+	Obj     ObjTool
+	UI      UI
+}
+
+// Writer provides a mechanism to write data under a certain name,
+// typically a filename.
+type Writer interface {
+	Open(name string) (io.WriteCloser, error)
+}
+
+// A FlagSet creates and parses command-line flags.
+// It is similar to the standard flag.FlagSet.
+type FlagSet interface {
+	// Bool, Int, Float64, and String define new flags,
+	// like the functions of the same name in package flag.
+	Bool(name string, def bool, usage string) *bool
+	Int(name string, def int, usage string) *int
+	Float64(name string, def float64, usage string) *float64
+	String(name string, def string, usage string) *string
+
+	// BoolVar, IntVar, Float64Var, and StringVar define new flags referencing
+	// a given pointer, like the functions of the same name in package flag.
+	BoolVar(pointer *bool, name string, def bool, usage string)
+	IntVar(pointer *int, name string, def int, usage string)
+	Float64Var(pointer *float64, name string, def float64, usage string)
+	StringVar(pointer *string, name string, def string, usage string)
+
+	// StringList is similar to String but allows multiple values for a
+	// single flag
+	StringList(name string, def string, usage string) *[]*string
+
+	// ExtraUsage returns any additional text that should be
+	// printed after the standard usage message.
+	// The typical use of ExtraUsage is to show any custom flags
+	// defined by the specific pprof plugins being used.
+	ExtraUsage() string
+
+	// Parse initializes the flags with their values for this run
+	// and returns the non-flag command line arguments.
+	// If an unknown flag is encountered or there are no arguments,
+	// Parse should call usage and return nil.
+	Parse(usage func()) []string
+}
+
+// A Fetcher reads and returns the profile named by src.  src can be a
+// local file path or a URL. duration and timeout are units specified
+// by the end user, or 0 by default. duration refers to the length of
+// the profile collection, if applicable, and timeout is the amount of
+// time to wait for a profile before returning an error. Returns the
+// fetched profile, the URL of the actual source of the profile, or an
+// error.
+type Fetcher interface {
+	Fetch(src string, duration, timeout time.Duration) (*profile.Profile, string, error)
+}
+
+// A Symbolizer introduces symbol information into a profile.
+type Symbolizer interface {
+	Symbolize(mode string, srcs MappingSources, prof *profile.Profile) error
+}
+
+// MappingSources map each profile.Mapping to the source of the profile.
+// The key is either Mapping.File or Mapping.BuildId.
+type MappingSources map[string][]struct {
+	Source string // URL of the source the mapping was collected from
+	Start  uint64 // delta applied to addresses from this source (to represent Merge adjustments)
+}
+
+// An ObjTool inspects shared libraries and executable files.
+type ObjTool interface {
+	// Open opens the named object file.  If the object is a shared
+	// library, start/limit/offset are the addresses where it is mapped
+	// into memory in the address space being inspected.
+	Open(file string, start, limit, offset uint64) (ObjFile, error)
+
+	// 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)
+}
+
+// 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
+}
+
+// An ObjFile is a single object file: a shared library or executable.
+type ObjFile interface {
+	// Name returns the underlyinf file name, if available
+	Name() string
+
+	// Base returns the base address to use when looking up symbols in the file.
+	Base() uint64
+
+	// BuildID returns the GNU build ID of the file, or an empty string.
+	BuildID() string
+
+	// 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.
+	SourceLine(addr uint64) ([]Frame, error)
+
+	// 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.
+	Symbols(r *regexp.Regexp, addr uint64) ([]*Sym, error)
+
+	// Close closes the file, releasing associated resources.
+	Close() error
+}
+
+// A Frame describes a single line in a source file.
+type Frame struct {
+	Func string // name of function
+	File string // source file name
+	Line int    // line in file
+}
+
+// A Sym describes a single symbol in an object file.
+type Sym struct {
+	Name  []string // names of symbol (many if symbol was dedup'ed)
+	File  string   // object file containing symbol
+	Start uint64   // start virtual address
+	End   uint64   // virtual address of last byte in sym (Start+size-1)
+}
+
+// A UI manages user interactions.
+type UI interface {
+	// Read returns a line of text (a command) read from the user.
+	// prompt is printed before reading the command.
+	ReadLine(prompt string) (string, error)
+
+	// Print shows a message to the user.
+	// It formats the text as fmt.Print would and adds a final \n if not already present.
+	// For line-based UI, Print writes to standard error.
+	// (Standard output is reserved for report data.)
+	Print(...interface{})
+
+	// PrintErr shows an error message to the user.
+	// It formats the text as fmt.Print would and adds a final \n if not already present.
+	// For line-based UI, PrintErr writes to standard error.
+	PrintErr(...interface{})
+
+	// IsTerminal returns whether the UI is known to be tied to an
+	// interactive terminal (as opposed to being redirected to a file).
+	IsTerminal() bool
+
+	// SetAutoComplete instructs the UI to call complete(cmd) to obtain
+	// the auto-completion of cmd, if the UI supports auto-completion at all.
+	SetAutoComplete(complete func(string) string)
+}

src/internal/proftest/proftest.go

+// 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.
+
+// Package proftest provides some utility routines to test other
+// packages related to profiles.
+package proftest
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"testing"
+)
+
+// Diff compares two byte arrays using the diff tool to highlight the
+// differences. It is meant for testing purposes to display the
+// differences between expected and actual output.
+func Diff(b1, b2 []byte) (data []byte, err error) {
+	f1, err := ioutil.TempFile("", "proto_test")
+	if err != nil {
+		return nil, err
+	}
+	defer os.Remove(f1.Name())
+	defer f1.Close()
+
+	f2, err := ioutil.TempFile("", "proto_test")
+	if err != nil {
+		return nil, err
+	}
+	defer os.Remove(f2.Name())
+	defer f2.Close()
+
+	f1.Write(b1)
+	f2.Write(b2)
+
+	data, err = exec.Command("diff", "-u", f1.Name(), f2.Name()).CombinedOutput()
+	if len(data) > 0 {
+		// diff exits with a non-zero status when the files don't match.
+		// Ignore that failure as long as we get output.
+		err = nil
+	}
+	return
+}
+
+// EncodeJSON encodes a value into a byte array. This is intended for
+// testing purposes.
+func EncodeJSON(x interface{}) []byte {
+	data, err := json.MarshalIndent(x, "", "    ")
+	if err != nil {
+		panic(err)
+	}
+	data = append(data, '\n')
+	return data
+}
+
+// TestUI implements the plugin.UI interface, triggering test failures
+// if more than Ignore errors are printed.
+type TestUI struct {
+	T      *testing.T
+	Ignore int
+}
+
+// ReadLine returns no input, as no input is expected during testing.
+func (ui *TestUI) ReadLine(_ string) (string, error) {
+	return "", fmt.Errorf("no input")
+}
+
+// Print messages are discarded by the test UI.
+func (ui *TestUI) Print(args ...interface{}) {
+}
+
+// PrintErr messages may trigger an error failure. A fixed number of
+// error messages are permitted when appropriate.
+func (ui *TestUI) PrintErr(args ...interface{}) {
+	if ui.Ignore > 0 {
+		ui.Ignore--
+		return
+	}
+	ui.T.Error(args)
+}
+
+// IsTerminal indicates if the UI is an interactive terminal.
+func (ui *TestUI) IsTerminal() bool {
+	return false
+}
+
+// SetAutoComplete is not supported by the test UI.
+func (ui *TestUI) SetAutoComplete(_ func(string) string) {
+}

src/internal/report/report.go

+// 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.
+
+// Package report summarizes a performance profile into a
+// human-readable report.
+package report
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"internal/graph"
+	"internal/measurement"
+	"internal/plugin"
+	"profile"
+)
+
+// Generate generates a report as directed by the Report.
+func Generate(w io.Writer, rpt *Report, obj plugin.ObjTool) error {
+	o := rpt.options
+
+	switch o.OutputFormat {
+	case Dot:
+		return printDOT(w, rpt)
+	case Tree:
+		return printTree(w, rpt)
+	case Text:
+		return printText(w, rpt)
+	case Traces:
+		return printTraces(w, rpt)
+	case Raw:
+		fmt.Fprint(w, rpt.prof.String())
+		return nil
+	case Tags:
+		return printTags(w, rpt)
+	case Proto:
+		return rpt.prof.Write(w)
+	case TopProto:
+		return printTopProto(w, rpt)
+	case Dis:
+		return printAssembly(w, rpt, obj)
+	case List:
+		return printSource(w, rpt)
+	case WebList:
+		return printWebSource(w, rpt, obj)
+	case Callgrind:
+		return printCallgrind(w, rpt)
+	}
+	return fmt.Errorf("unexpected output format")
+}
+
+// newTrimmedGraph creates a graph for this report, trimmed according
+// to the report options.
+func (rpt *Report) newTrimmedGraph() (g *graph.Graph, origCount, droppedNodes, droppedEdges int) {
+	o := rpt.options
+
+	// Build a graph and refine it. On each refinement step we must rebuild the graph from the samples,
+	// as the graph itself doesn't contain enough information to preserve full precision.
+
+	// First step: Build complete graph to identify low frequency nodes, based on their cum weight.
+	g = rpt.newGraph(nil)
+	totalValue, _ := g.Nodes.Sum()
+	nodeCutoff := abs64(int64(float64(totalValue) * o.NodeFraction))
+	edgeCutoff := abs64(int64(float64(totalValue) * o.EdgeFraction))
+
+	// Filter out nodes with cum value below nodeCutoff.
+	if nodeCutoff > 0 {
+		if nodesKept := g.DiscardLowFrequencyNodes(nodeCutoff); len(g.Nodes) != len(nodesKept) {
+			droppedNodes = len(g.Nodes) - len(nodesKept)
+			g = rpt.newGraph(nodesKept)
+		}
+	}
+	origCount = len(g.Nodes)
+
+	// Second step: Limit the total number of nodes. Apply specialized heuristics to improve
+	// visualization when generating dot output.
+	visualMode := o.OutputFormat == Dot
+	g.SortNodes(o.CumSort, visualMode)
+	if nodeCount := o.NodeCount; nodeCount > 0 {
+		// Remove low frequency tags and edges as they affect selection.
+		g.TrimLowFrequencyTags(nodeCutoff)
+		g.TrimLowFrequencyEdges(edgeCutoff)
+		if nodesKept := g.SelectTopNodes(nodeCount, visualMode); len(nodesKept) != len(g.Nodes) {
+			g = rpt.newGraph(nodesKept)
+			g.SortNodes(o.CumSort, visualMode)
+		}
+	}
+
+	// Final step: Filter out low frequency tags and edges, and remove redundant edges that clutter
+	// the graph.
+	g.TrimLowFrequencyTags(nodeCutoff)
+	droppedEdges = g.TrimLowFrequencyEdges(edgeCutoff)
+	if visualMode {
+		g.RemoveRedundantEdges()
+	}
+	return
+}
+
+func (rpt *Report) selectOutputUnit(g *graph.Graph) {
+	o := rpt.options
+
+	// Select best unit for profile output.
+	// Find the appropriate units for the smallest non-zero sample
+	if o.OutputUnit != "minimum" || len(g.Nodes) == 0 {
+		return
+	}
+	var minValue int64
+
+	for _, n := range g.Nodes {
+		nodeMin := abs64(n.Flat)
+		if nodeMin == 0 {
+			nodeMin = abs64(n.Cum)
+		}
+		if nodeMin > 0 && (minValue == 0 || nodeMin < minValue) {
+			minValue = nodeMin
+		}
+	}
+	maxValue := rpt.total
+	if minValue == 0 {
+		minValue = maxValue
+	}
+
+	if r := o.Ratio; r > 0 && r != 1 {
+		minValue = int64(float64(minValue) * r)
+		maxValue = int64(float64(maxValue) * r)
+	}
+
+	_, minUnit := measurement.Scale(minValue, o.SampleUnit, "minimum")
+	_, maxUnit := measurement.Scale(maxValue, o.SampleUnit, "minimum")
+
+	unit := minUnit
+	if minUnit != maxUnit && minValue*100 < maxValue && o.OutputFormat != Callgrind {
+		// Minimum and maximum values have different units. Scale
+		// minimum by 100 to use larger units, allowing minimum value to
+		// be scaled down to 0.01, except for callgrind reports since
+		// they can only represent integer values.
+		_, unit = measurement.Scale(100*minValue, o.SampleUnit, "minimum")
+	}
+
+	if unit != "" {
+		o.OutputUnit = unit
+	} else {
+		o.OutputUnit = o.SampleUnit
+	}
+}
+
+// newGraph creates a new graph for this report. If nodes is non-nil,
+// only nodes whose info matches are included. Otherwise, all nodes
+// are included, without trimming.
+func (rpt *Report) newGraph(nodes graph.NodeSet) *graph.Graph {
+	o := rpt.options
+
+	// Clean up file paths using heuristics.
+	prof := rpt.prof
+	for _, f := range prof.Function {
+		f.Filename = trimPath(f.Filename)
+	}
+
+	gopt := &graph.Options{
+		SampleValue:  o.SampleValue,
+		FormatTag:    formatTag,
+		CallTree:     o.CallTree && o.OutputFormat == Dot,
+		DropNegative: o.DropNegative,
+		KeptNodes:    nodes,
+	}
+
+	// Only keep binary names for disassembly-based reports, otherwise
+	// remove it to allow merging of functions across binaries.
+	switch o.OutputFormat {
+	case Raw, List, WebList, Dis:
+		gopt.ObjNames = true
+	}
+
+	return graph.New(rpt.prof, gopt)
+}
+
+func formatTag(v int64, key string) string {
+	return measurement.Label(v, key)
+}
+
+func printTopProto(w io.Writer, rpt *Report) error {
+	p := rpt.prof
+	o := rpt.options
+	g, _, _, _ := rpt.newTrimmedGraph()
+	rpt.selectOutputUnit(g)
+
+	out := profile.Profile{
+		SampleType: []*profile.ValueType{
+			{Type: "cum", Unit: o.OutputUnit},
+			{Type: "flat", Unit: o.OutputUnit},
+		},
+		TimeNanos:     p.TimeNanos,
+		DurationNanos: p.DurationNanos,
+		PeriodType:    p.PeriodType,
+		Period:        p.Period,
+	}
+	var flatSum int64
+	for i, n := range g.Nodes {
+		name, flat, cum := n.Info.PrintableName(), n.Flat, n.Cum
+
+		flatSum += flat
+		f := &profile.Function{
+			ID:         uint64(i + 1),
+			Name:       name,
+			SystemName: name,
+		}
+		l := &profile.Location{
+			ID: uint64(i + 1),
+			Line: []profile.Line{
+				{
+					Function: f,
+				},
+			},
+		}
+
+		fv, _ := measurement.Scale(flat, o.SampleUnit, o.OutputUnit)
+		cv, _ := measurement.Scale(cum, o.SampleUnit, o.OutputUnit)
+		s := &profile.Sample{
+			Location: []*profile.Location{l},
+			Value:    []int64{int64(cv), int64(fv)},
+		}
+		out.Function = append(out.Function, f)
+		out.Location = append(out.Location, l)
+		out.Sample = append(out.Sample, s)
+	}
+
+	return out.Write(w)
+}
+
+// printAssembly prints an annotated assembly listing.
+func printAssembly(w io.Writer, rpt *Report, obj plugin.ObjTool) error {
+	o := rpt.options
+	prof := rpt.prof
+
+	g := rpt.newGraph(nil)
+
+	// If the regexp source can be parsed as an address, also match
+	// functions that land on that address.
+	var address *uint64
+	if hex, err := strconv.ParseUint(o.Symbol.String(), 0, 64); err == nil {
+		address = &hex
+	}
+
+	fmt.Fprintln(w, "Total:", rpt.formatValue(rpt.total))
+	symbols := symbolsFromBinaries(prof, g, o.Symbol, address, obj)
+	symNodes := nodesPerSymbol(g.Nodes, symbols)
+	// Sort function names for printing.
+	var syms objSymbols
+	for s := range symNodes {
+		syms = append(syms, s)
+	}
+	sort.Sort(syms)
+
+	// Correlate the symbols from the binary with the profile samples.
+	for _, s := range syms {
+		sns := symNodes[s]
+
+		// Gather samples for this symbol.
+		flatSum, cumSum := sns.Sum()
+
+		// Get the function assembly.
+		insns, err := obj.Disasm(s.sym.File, s.sym.Start, s.sym.End)
+		if err != nil {
+			return err
+		}
+
+		ns := annotateAssembly(insns, sns, s.base)
+
+		fmt.Fprintf(w, "ROUTINE ======================== %s\n", s.sym.Name[0])
+		for _, name := range s.sym.Name[1:] {
+			fmt.Fprintf(w, "    AKA ======================== %s\n", name)
+		}
+		fmt.Fprintf(w, "%10s %10s (flat, cum) %s of Total\n",
+			rpt.formatValue(flatSum), rpt.formatValue(cumSum),
+			percentage(cumSum, rpt.total))
+
+		for _, n := range ns {
+			fmt.Fprintf(w, "%10s %10s %10x: %s\n", valueOrDot(n.Flat, rpt), valueOrDot(n.Cum, rpt), n.Info.Address, n.Info.Name)
+		}
+	}
+	return nil
+}
+
+// symbolsFromBinaries examines the binaries listed on the profile
+// that have associated samples, and identifies symbols matching rx.
+func symbolsFromBinaries(prof *profile.Profile, g *graph.Graph, rx *regexp.Regexp, address *uint64, obj plugin.ObjTool) []*objSymbol {
+	hasSamples := make(map[string]bool)
+	// Only examine mappings that have samples that match the
+	// regexp. This is an optimization to speed up pprof.
+	for _, n := range g.Nodes {
+		if name := n.Info.PrintableName(); rx.MatchString(name) && n.Info.Objfile != "" {
+			hasSamples[n.Info.Objfile] = true
+		}
+	}
+
+	// Walk all mappings looking for matching functions with samples.
+	var objSyms []*objSymbol
+	for _, m := range prof.Mapping {
+		if !hasSamples[filepath.Base(m.File)] {
+			if address == nil || !(m.Start <= *address && *address <= m.Limit) {
+				continue
+			}
+		}
+
+		f, err := obj.Open(m.File, m.Start, m.Limit, m.Offset)
+		if err != nil {
+			fmt.Printf("%v\n", err)
+			continue
+		}
+
+		// Find symbols in this binary matching the user regexp.
+		var addr uint64
+		if address != nil {
+			addr = *address
+		}
+		msyms, err := f.Symbols(rx, addr)
+		base := f.Base()
+		f.Close()
+		if err != nil {
+			continue
+		}
+		for _, ms := range msyms {
+			objSyms = append(objSyms,
+				&objSymbol{
+					sym:  ms,
+					base: base,
+				},
+			)
+		}
+	}
+
+	return objSyms
+}
+
+// objSym represents a symbol identified from a binary. It includes
+// the SymbolInfo from the disasm package and the base that must be
+// added to correspond to sample addresses
+type objSymbol struct {
+	sym  *plugin.Sym
+	base uint64
+}
+
+// objSymbols is a wrapper type to enable sorting of []*objSymbol.
+type objSymbols []*objSymbol
+
+func (o objSymbols) Len() int {
+	return len(o)
+}
+
+func (o objSymbols) Less(i, j int) bool {
+	if namei, namej := o[i].sym.Name[0], o[j].sym.Name[0]; namei != namej {
+		return namei < namej
+	}
+	return o[i].sym.Start < o[j].sym.Start
+}
+
+func (o objSymbols) Swap(i, j int) {
+	o[i], o[j] = o[j], o[i]
+}
+
+// nodesPerSymbol classifies nodes into a group of symbols.
+func nodesPerSymbol(ns graph.Nodes, symbols []*objSymbol) map[*objSymbol]graph.Nodes {
+	symNodes := make(map[*objSymbol]graph.Nodes)
+	for _, s := range symbols {
+		// Gather samples for this symbol.
+		for _, n := range ns {
+			address := n.Info.Address - s.base
+			if address >= s.sym.Start && address < s.sym.End {
+				symNodes[s] = append(symNodes[s], n)
+			}
+		}
+	}
+	return symNodes
+}
+
+// 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 {
+	// Add end marker to simplify printing loop.
+	insns = append(insns, plugin.Inst{^uint64(0), "", "", 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,
+			},
+		}
+
+		// 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.Flat += samples[s].Flat
+			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
+			}
+		}
+		asm = append(asm, &n)
+	}
+
+	return asm
+}
+
+// valueOrDot formats a value according to a report, intercepting zero
+// values.
+func valueOrDot(value int64, rpt *Report) string {
+	if value == 0 {
+		return "."
+	}
+	return rpt.formatValue(value)
+}
+
+// canAccessFile determines if the filename can be opened for reading.
+func canAccessFile(path string) bool {
+	if fi, err := os.Stat(path); err == nil {
+		return fi.Mode().Perm()&0400 != 0
+	}
+	return false
+}
+
+// printTags collects all tags referenced in the profile and prints
+// them in a sorted table.
+func printTags(w io.Writer, rpt *Report) error {
+	p := rpt.prof
+
+	// Hashtable to keep accumulate tags as key,value,count.
+	tagMap := make(map[string]map[string]int64)
+	for _, s := range p.Sample {
+		for key, vals := range s.Label {
+			for _, val := range vals {
+				if valueMap, ok := tagMap[key]; ok {
+					valueMap[val] = valueMap[val] + s.Value[0]
+					continue
+				}
+				valueMap := make(map[string]int64)
+				valueMap[val] = s.Value[0]
+				tagMap[key] = valueMap
+			}
+		}
+		for key, vals := range s.NumLabel {
+			for _, nval := range vals {
+				val := measurement.Label(nval, key)
+				if valueMap, ok := tagMap[key]; ok {
+					valueMap[val] = valueMap[val] + s.Value[0]
+					continue
+				}
+				valueMap := make(map[string]int64)
+				valueMap[val] = s.Value[0]
+				tagMap[key] = valueMap
+			}
+		}
+	}
+
+	tagKeys := make([]*graph.Tag, 0, len(tagMap))
+	for key := range tagMap {
+		tagKeys = append(tagKeys, &graph.Tag{Name: key})
+	}
+	for _, tagKey := range graph.SortTags(tagKeys, true) {
+		var total int64
+		key := tagKey.Name
+		tags := make([]*graph.Tag, 0, len(tagMap[key]))
+		for t, c := range tagMap[key] {
+			total += c
+			tags = append(tags, &graph.Tag{Name: t, Flat: c})
+		}
+
+		fmt.Fprintf(w, "%s: Total %d\n", key, total)
+		for _, t := range graph.SortTags(tags, true) {
+			if total > 0 {
+				fmt.Fprintf(w, "  %8d (%s): %s\n", t.Flat,
+					percentage(t.Flat, total), t.Name)
+			} else {
+				fmt.Fprintf(w, "  %8d: %s\n", t.Flat, t.Name)
+			}
+		}
+		fmt.Fprintln(w)
+	}
+	return nil
+}
+
+// printText prints a flat text report for a profile.
+func printText(w io.Writer, rpt *Report) error {
+	g, origCount, droppedNodes, _ := rpt.newTrimmedGraph()
+	rpt.selectOutputUnit(g)
+
+	fmt.Fprintln(w, strings.Join(reportLabels(rpt, g, origCount, droppedNodes, 0, false), "\n"))
+
+	fmt.Fprintf(w, "%10s %5s%% %5s%% %10s %5s%%\n",
+		"flat", "flat", "sum", "cum", "cum")
+
+	var flatSum int64
+	for _, n := range g.Nodes {
+		name, flat, cum := n.Info.PrintableName(), n.Flat, n.Cum
+
+		var inline, noinline bool
+		for _, e := range n.In {
+			if e.Inline {
+				inline = true
+			} else {
+				noinline = true
+			}
+		}
+
+		if inline {
+			if noinline {
+				name = name + " (partial-inline)"
+			} else {
+				name = name + " (inline)"
+			}
+		}
+
+		flatSum += flat
+		fmt.Fprintf(w, "%10s %s %s %10s %s  %s\n",
+			rpt.formatValue(flat),
+			percentage(flat, rpt.total),
+			percentage(flatSum, rpt.total),
+			rpt.formatValue(cum),
+			percentage(cum, rpt.total),
+			name)
+	}
+	return nil
+}
+
+// printTraces prints all traces from a profile.
+func printTraces(w io.Writer, rpt *Report) error {
+	fmt.Fprintln(w, strings.Join(ProfileLabels(rpt), "\n"))
+
+	prof := rpt.prof
+	o := rpt.options
+
+	const separator = "-----------+-------------------------------------------------------"
+
+	locations := graph.NewLocInfo(prof, false)
+
+	for _, sample := range prof.Sample {
+		var stack []graph.NodeInfo
+		for _, loc := range sample.Location {
+			id := loc.ID
+			stack = append(stack, locations[id]...)
+		}
+
+		if len(stack) == 0 {
+			continue
+		}
+
+		fmt.Fprintln(w, separator)
+		// Print any text labels for the sample.
+		var labels []string
+		for s, vs := range sample.Label {
+			labels = append(labels, fmt.Sprintf("%10s:  %s\n", s, strings.Join(vs, " ")))
+		}
+		sort.Strings(labels)
+		fmt.Fprint(w, strings.Join(labels, ""))
+		// Print call stack.
+		fmt.Fprintf(w, "%10s   %s\n",
+			rpt.formatValue(o.SampleValue(sample.Value)),
+			stack[0].PrintableName())
+
+		for _, s := range stack[1:] {
+			fmt.Fprintf(w, "%10s   %s\n", "", s.PrintableName())
+		}
+	}
+	fmt.Fprintln(w, separator)
+	return nil
+}
+
+// printCallgrind prints a graph for a profile on callgrind format.
+func printCallgrind(w io.Writer, rpt *Report) error {
+	o := rpt.options
+	rpt.options.NodeFraction = 0
+	rpt.options.EdgeFraction = 0
+	rpt.options.NodeCount = 0
+
+	g, _, _, _ := rpt.newTrimmedGraph()
+	rpt.selectOutputUnit(g)
+
+	fmt.Fprintln(w, "events:", o.SampleType+"("+o.OutputUnit+")")
+
+	files := make(map[string]int)
+	names := make(map[string]int)
+	for _, n := range g.Nodes {
+		fmt.Fprintln(w, "fl="+callgrindName(files, n.Info.File))
+		fmt.Fprintln(w, "fn="+callgrindName(names, n.Info.Name))
+		sv, _ := measurement.Scale(n.Flat, o.SampleUnit, o.OutputUnit)
+		fmt.Fprintf(w, "%d %d\n", n.Info.Lineno, int64(sv))
+
+		// Print outgoing edges.
+		for _, out := range n.Out.Sort() {
+			c, _ := measurement.Scale(out.Weight, o.SampleUnit, o.OutputUnit)
+			callee := out.Dest
+			fmt.Fprintln(w, "cfl="+callgrindName(files, callee.Info.File))
+			fmt.Fprintln(w, "cfn="+callgrindName(names, callee.Info.Name))
+			// pprof doesn't have a flat weight for a call, leave as 0.
+			fmt.Fprintln(w, "calls=0", callee.Info.Lineno)
+			fmt.Fprintln(w, n.Info.Lineno, int64(c))
+		}
+		fmt.Fprintln(w)
+	}
+
+	return nil
+}
+
+// callgrindName implements the callgrind naming compression scheme.
+// For names not previously seen returns "(N) name", where N is a
+// unique index.  For names previously seen returns "(N)" where N is
+// the index returned the first time.
+func callgrindName(names map[string]int, name string) string {
+	if name == "" {
+		return ""
+	}
+	if id, ok := names[name]; ok {
+		return fmt.Sprintf("(%d)", id)
+	}
+	id := len(names) + 1
+	names[name] = id
+	return fmt.Sprintf("(%d) %s", id, name)
+}
+
+// printTree prints a tree-based report in text form.
+func printTree(w io.Writer, rpt *Report) error {
+	const separator = "----------------------------------------------------------+-------------"
+	const legend = "      flat  flat%   sum%        cum   cum%   calls calls% + context 	 	 "
+
+	g, origCount, droppedNodes, _ := rpt.newTrimmedGraph()
+	rpt.selectOutputUnit(g)
+
+	fmt.Fprintln(w, strings.Join(reportLabels(rpt, g, origCount, droppedNodes, 0, false), "\n"))
+
+	fmt.Fprintln(w, separator)
+	fmt.Fprintln(w, legend)
+	var flatSum int64
+
+	rx := rpt.options.Symbol
+	for _, n := range g.Nodes {
+		name, flat, cum := n.Info.PrintableName(), n.Flat, n.Cum
+
+		// Skip any entries that do not match the regexp (for the "peek" command).
+		if rx != nil && !rx.MatchString(name) {
+			continue
+		}
+
+		fmt.Fprintln(w, separator)
+		// Print incoming edges.
+		inEdges := n.In.Sort()
+		for _, in := range inEdges {
+			var inline string
+			if in.Inline {
+				inline = " (inline)"
+			}
+			fmt.Fprintf(w, "%50s %s |   %s%s\n", rpt.formatValue(in.Weight),
+				percentage(in.Weight, cum), in.Src.Info.PrintableName(), inline)
+		}
+
+		// Print current node.
+		flatSum += flat
+		fmt.Fprintf(w, "%10s %s %s %10s %s                | %s\n",
+			rpt.formatValue(flat),
+			percentage(flat, rpt.total),
+			percentage(flatSum, rpt.total),
+			rpt.formatValue(cum),
+			percentage(cum, rpt.total),
+			name)
+
+		// Print outgoing edges.
+		outEdges := n.Out.Sort()
+		for _, out := range outEdges {
+			var inline string
+			if out.Inline {
+				inline = " (inline)"
+			}
+			fmt.Fprintf(w, "%50s %s |   %s%s\n", rpt.formatValue(out.Weight),
+				percentage(out.Weight, cum), out.Dest.Info.PrintableName(), inline)
+		}
+	}
+	if len(g.Nodes) > 0 {
+		fmt.Fprintln(w, separator)
+	}
+	return nil
+}
+
+// printDOT prints an annotated callgraph in DOT format.
+func printDOT(w io.Writer, rpt *Report) error {
+	g, origCount, droppedNodes, droppedEdges := rpt.newTrimmedGraph()
+	rpt.selectOutputUnit(g)
+	labels := reportLabels(rpt, g, origCount, droppedNodes, droppedEdges, true)
+
+	c := &graph.DotConfig{
+		Title:       rpt.options.Title,
+		Labels:      labels,
+		FormatValue: rpt.formatValue,
+		Total:       rpt.total,
+	}
+	graph.ComposeDot(w, g, &graph.DotAttributes{}, c)
+	return nil
+}
+
+// percentage computes the percentage of total of a value, and encodes
+// it as a string. At least two digits of precision are printed.
+func percentage(value, total int64) string {
+	var ratio float64
+	if total != 0 {
+		ratio = math.Abs(float64(value)/float64(total)) * 100
+	}
+	switch {
+	case math.Abs(ratio) >= 99.95 && math.Abs(ratio) <= 100.05:
+		return "  100%"
+	case math.Abs(ratio) >= 1.0:
+		return fmt.Sprintf("%5.2f%%", ratio)
+	default:
+		return fmt.Sprintf("%5.2g%%", ratio)
+	}
+}
+
+// ProfileLabels returns printable labels for a profile.
+func ProfileLabels(rpt *Report) []string {
+	label := []string{}
+	prof := rpt.prof
+	o := rpt.options
+	if len(prof.Mapping) > 0 {
+		if prof.Mapping[0].File != "" {
+			label = append(label, "File: "+filepath.Base(prof.Mapping[0].File))
+		}
+		if prof.Mapping[0].BuildID != "" {
+			label = append(label, "Build ID: "+prof.Mapping[0].BuildID)
+		}
+	}
+	label = append(label, prof.Comments...)
+	if o.SampleType != "" {
+		label = append(label, "Type: "+o.SampleType)
+	}
+	if prof.TimeNanos != 0 {
+		const layout = "Jan 2, 2006 at 3:04pm (MST)"
+		label = append(label, "Time: "+time.Unix(0, prof.TimeNanos).Format(layout))
+	}
+	if prof.DurationNanos != 0 {
+		duration := measurement.Label(prof.DurationNanos, "nanoseconds")
+		totalNanos, totalUnit := measurement.Scale(rpt.total, o.SampleUnit, "nanoseconds")
+		var ratio string
+		if totalUnit == "ns" && totalNanos != 0 {
+			ratio = "(" + percentage(int64(totalNanos), prof.DurationNanos) + ")"
+		}
+		label = append(label, fmt.Sprintf("Duration: %s, Total samples = %s %s", duration, rpt.formatValue(rpt.total), ratio))
+	}
+	return label
+}
+
+// reportLabels returns printable labels for a report. Includes
+// profileLabels.
+func reportLabels(rpt *Report, g *graph.Graph, origCount, droppedNodes, droppedEdges int, fullHeaders bool) []string {
+	nodeFraction := rpt.options.NodeFraction
+	edgeFraction := rpt.options.EdgeFraction
+	nodeCount := rpt.options.NodeCount
+
+	var label []string
+	if len(rpt.options.ProfileLabels) > 0 {
+		for _, l := range rpt.options.ProfileLabels {
+			label = append(label, l)
+		}
+	} else if fullHeaders || !rpt.options.CompactLabels {
+		label = ProfileLabels(rpt)
+	}
+
+	var flatSum int64
+	for _, n := range g.Nodes {
+		flatSum = flatSum + n.Flat
+	}
+
+	label = append(label, fmt.Sprintf("Showing nodes accounting for %s, %s of %s total", rpt.formatValue(flatSum), strings.TrimSpace(percentage(flatSum, rpt.total)), rpt.formatValue(rpt.total)))
+
+	if rpt.total != 0 {
+		if droppedNodes > 0 {
+			label = append(label, genLabel(droppedNodes, "node", "cum",
+				rpt.formatValue(abs64(int64(float64(rpt.total)*nodeFraction)))))
+		}
+		if droppedEdges > 0 {
+			label = append(label, genLabel(droppedEdges, "edge", "freq",
+				rpt.formatValue(abs64(int64(float64(rpt.total)*edgeFraction)))))
+		}
+		if nodeCount > 0 && nodeCount < origCount {
+			label = append(label, fmt.Sprintf("Showing top %d nodes out of %d (cum >= %s)",
+				nodeCount, origCount,
+				rpt.formatValue(g.Nodes[len(g.Nodes)-1].Cum)))
+		}
+	}
+	return label
+}
+
+func genLabel(d int, n, l, f string) string {
+	if d > 1 {
+		n = n + "s"
+	}
+	return fmt.Sprintf("Dropped %d %s (%s <= %s)", d, n, l, f)
+}
+
+// Output formats.
+const (
+	Proto = iota
+	Dot
+	Tags
+	Tree
+	Text
+	Traces
+	Raw
+	Dis
+	List
+	WebList
+	Callgrind
+	TopProto
+)
+
+// Options are the formatting and filtering options used to generate a
+// profile.
+type Options struct {
+	OutputFormat int
+
+	CumSort             bool
+	CallTree            bool
+	DropNegative        bool
+	PositivePercentages bool
+	CompactLabels       bool
+	Ratio               float64
+	Title               string
+	ProfileLabels       []string
+
+	NodeCount    int
+	NodeFraction float64
+	EdgeFraction float64
+
+	SampleValue func(s []int64) int64
+	SampleType  string
+	SampleUnit  string // Unit for the sample data from the profile.
+
+	OutputUnit string // Units for data formatting in report.
+
+	Symbol *regexp.Regexp // Symbols to include on disassembly report.
+}
+
+// New builds a new report indexing the sample values interpreting the
+// samples with the provided function.
+func New(prof *profile.Profile, o *Options) *Report {
+	format := func(v int64) string {
+		if r := o.Ratio; r > 0 && r != 1 {
+			fv := float64(v) * r
+			v = int64(fv)
+		}
+		return measurement.ScaledLabel(v, o.SampleUnit, o.OutputUnit)
+	}
+	return &Report{prof, computeTotal(prof, o.SampleValue, !o.PositivePercentages),
+		o, format}
+}
+
+// NewDefault builds a new report indexing the last sample value
+// available.
+func NewDefault(prof *profile.Profile, options Options) *Report {
+	index := len(prof.SampleType) - 1
+	o := &options
+	if o.Title == "" && len(prof.Mapping) > 0 {
+		o.Title = filepath.Base(prof.Mapping[0].File)
+	}
+	o.SampleType = prof.SampleType[index].Type
+	o.SampleUnit = strings.ToLower(prof.SampleType[index].Unit)
+	o.SampleValue = func(v []int64) int64 {
+		return v[index]
+	}
+	return New(prof, o)
+}
+
+// computeTotal computes the sum of all sample values. This will be
+// used to compute percentages. If includeNegative is set, use use
+// absolute values to provide a meaningful percentage for both
+// negative and positive values. Otherwise only use positive values,
+// which is useful when comparing profiles from different jobs.
+func computeTotal(prof *profile.Profile, value func(v []int64) int64, includeNegative bool) int64 {
+	var ret int64
+	for _, sample := range prof.Sample {
+		if v := value(sample.Value); v > 0 {
+			ret += v
+		} else if includeNegative {
+			ret -= v
+		}
+	}
+	return ret
+}
+
+// Report contains the data and associated routines to extract a
+// report from a profile.
+type Report struct {
+	prof        *profile.Profile
+	total       int64
+	options     *Options
+	formatValue func(int64) string
+}
+
+func (rpt *Report) formatTags(s *profile.Sample) (string, bool) {
+	var labels []string
+	for key, vals := range s.Label {
+		for _, v := range vals {
+			labels = append(labels, key+":"+v)
+		}
+	}
+	for key, nvals := range s.NumLabel {
+		for _, v := range nvals {
+			labels = append(labels, measurement.Label(v, key))
+		}
+	}
+	if len(labels) == 0 {
+		return "", false
+	}
+	sort.Strings(labels)
+	return strings.Join(labels, `\n`), true
+}
+
+func abs64(i int64) int64 {
+	if i < 0 {
+		return -i
+	}
+	return i
+}

src/internal/report/report_test.go

+// 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.
+
+package report
+
+import (
+	"bytes"
+	"io/ioutil"
+	"path/filepath"
+	"regexp"
+	"testing"
+
+	"internal/binutils"
+	"profile"
+	"internal/proftest"
+)
+
+type testcase struct {
+	rpt  *Report
+	want string
+}
+
+func TestSource(t *testing.T) {
+	const path = "testdata/"
+
+	sampleValue1 := func(v []int64) int64 {
+		return v[1]
+	}
+
+	for _, tc := range []testcase{
+		{
+			rpt: New(
+				testProfile.Copy(),
+				&Options{
+					OutputFormat: List,
+					Symbol:       regexp.MustCompile(`.`),
+					Title:        filepath.Base(testProfile.Mapping[0].File),
+
+					SampleValue: sampleValue1,
+					SampleUnit:  testProfile.SampleType[1].Unit,
+				},
+			),
+			want: path + "source.rpt",
+		},
+		{
+			rpt: New(
+				testProfile.Copy(),
+				&Options{
+					OutputFormat: Dot,
+					CallTree:     true,
+					Symbol:       regexp.MustCompile(`.`),
+					Title:        filepath.Base(testProfile.Mapping[0].File),
+
+					SampleValue: sampleValue1,
+					SampleUnit:  testProfile.SampleType[1].Unit,
+				},
+			),
+			want: path + "source.dot",
+		},
+	} {
+		b := bytes.NewBuffer(nil)
+		if err := Generate(b, tc.rpt, &binutils.Binutils{}); err != nil {
+			t.Fatalf("%s: %v", tc.want, err)
+		}
+
+		gold, err := ioutil.ReadFile(tc.want)
+		if err != nil {
+			t.Fatalf("%s: %v", tc.want, err)
+		}
+		if string(b.String()) != string(gold) {
+			d, err := proftest.Diff(gold, b.Bytes())
+			if err != nil {
+				t.Fatalf("%s: %v", "source", err)
+			}
+			t.Error("source" + "\n" + string(d) + "\n" + "gold:\n" + tc.want)
+		}
+	}
+}
+
+var testM = []*profile.Mapping{
+	{
+		ID:              1,
+		HasFunctions:    true,
+		HasFilenames:    true,
+		HasLineNumbers:  true,
+		HasInlineFrames: true,
+	},
+}
+
+var testF = []*profile.Function{
+	{
+		ID:       1,
+		Name:     "main",
+		Filename: "testdata/source1",
+	},
+	{
+		ID:       2,
+		Name:     "foo",
+		Filename: "testdata/source1",
+	},
+	{
+		ID:       3,
+		Name:     "bar",
+		Filename: "testdata/source1",
+	},
+	{
+		ID:       4,
+		Name:     "tee",
+		Filename: "testdata/source2",
+	},
+}
+
+var testL = []*profile.Location{
+	{
+		ID:      1,
+		Mapping: testM[0],
+		Line: []profile.Line{
+			{
+				Function: testF[0],
+				Line:     2,
+			},
+		},
+	},
+	{
+		ID:      2,
+		Mapping: testM[0],
+		Line: []profile.Line{
+			{
+				Function: testF[1],
+				Line:     4,
+			},
+		},
+	},
+	{
+		ID:      3,
+		Mapping: testM[0],
+		Line: []profile.Line{
+			{
+				Function: testF[2],
+				Line:     10,
+			},
+		},
+	},
+	{
+		ID:      4,
+		Mapping: testM[0],
+		Line: []profile.Line{
+			{
+				Function: testF[3],
+				Line:     2,
+			},
+		},
+	},
+	{
+		ID:      5,
+		Mapping: testM[0],
+		Line: []profile.Line{
+			{
+				Function: testF[3],
+				Line:     8,
+			},
+		},
+	},
+}
+
+var testProfile = &profile.Profile{
+	PeriodType:    &profile.ValueType{Type: "cpu", Unit: "millisecond"},
+	Period:        10,
+	DurationNanos: 10e9,
+	SampleType: []*profile.ValueType{
+		{Type: "samples", Unit: "count"},
+		{Type: "cpu", Unit: "cycles"},
+	},
+	Sample: []*profile.Sample{
+		{
+			Location: []*profile.Location{testL[0]},
+			Value:    []int64{1, 1},
+		},
+		{
+			Location: []*profile.Location{testL[2], testL[1], testL[0]},
+			Value:    []int64{1, 10},
+		},
+		{
+			Location: []*profile.Location{testL[4], testL[2], testL[0]},
+			Value:    []int64{1, 100},
+		},
+		{
+			Location: []*profile.Location{testL[3], testL[0]},
+			Value:    []int64{1, 1000},
+		},
+		{
+			Location: []*profile.Location{testL[4], testL[3], testL[0]},
+			Value:    []int64{1, 10000},
+		},
+	},
+	Location: testL,
+	Function: testF,
+	Mapping:  testM,
+}

src/internal/report/source.go

+// 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.
+
+package report
+
+// This file contains routines related to the generation of annotated
+// source listings.
+
+import (
+	"bufio"
+	"fmt"
+	"html/template"
+	"io"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+
+	"internal/graph"
+	"internal/plugin"
+)
+
+// printSource prints an annotated source listing, include all
+// functions with samples that match the regexp rpt.options.symbol.
+// The sources are sorted by function name and then by filename to
+// eliminate potential nondeterminism.
+func printSource(w io.Writer, rpt *Report) error {
+	o := rpt.options
+	g := rpt.newGraph(nil)
+
+	// Identify all the functions that match the regexp provided.
+	// Group nodes for each matching function.
+	var functions graph.Nodes
+	functionNodes := make(map[string]graph.Nodes)
+	for _, n := range g.Nodes {
+		if !o.Symbol.MatchString(n.Info.Name) {
+			continue
+		}
+		if functionNodes[n.Info.Name] == nil {
+			functions = append(functions, n)
+		}
+		functionNodes[n.Info.Name] = append(functionNodes[n.Info.Name], n)
+	}
+	functions.Sort(graph.NameOrder)
+
+	fmt.Fprintf(w, "Total: %s\n", rpt.formatValue(rpt.total))
+	for _, fn := range functions {
+		name := fn.Info.Name
+
+		// Identify all the source files associated to this function.
+		// Group nodes for each source file.
+		var sourceFiles graph.Nodes
+		fileNodes := make(map[string]graph.Nodes)
+		for _, n := range functionNodes[name] {
+			if n.Info.File == "" {
+				continue
+			}
+			if fileNodes[n.Info.File] == nil {
+				sourceFiles = append(sourceFiles, n)
+			}
+			fileNodes[n.Info.File] = append(fileNodes[n.Info.File], n)
+		}
+
+		if len(sourceFiles) == 0 {
+			fmt.Fprintf(w, "No source information for %s\n", name)
+			continue
+		}
+
+		sourceFiles.Sort(graph.FileOrder)
+
+		// Print each file associated with this function.
+		for _, fl := range sourceFiles {
+			filename := fl.Info.File
+			fns := fileNodes[filename]
+			flatSum, cumSum := fns.Sum()
+
+			fnodes, path, err := getFunctionSource(name, filename, 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),
+				percentage(cumSum, rpt.total))
+
+			if err != nil {
+				fmt.Fprintf(w, " Error: %v\n", err)
+				continue
+			}
+
+			for _, fn := range fnodes {
+				fmt.Fprintf(w, "%10s %10s %6d:%s\n", valueOrDot(fn.Flat, rpt), valueOrDot(fn.Cum, rpt), fn.Info.Lineno, fn.Info.Name)
+			}
+		}
+	}
+	return nil
+}
+
+// printWebSource prints an annotated source listing, include all
+// functions with samples that match the regexp rpt.options.symbol.
+func printWebSource(w io.Writer, rpt *Report, obj plugin.ObjTool) error {
+	o := rpt.options
+	g := rpt.newGraph(nil)
+
+	// If the regexp source can be parsed as an address, also match
+	// functions that land on that address.
+	var address *uint64
+	if hex, err := strconv.ParseUint(o.Symbol.String(), 0, 64); err == nil {
+		address = &hex
+	}
+
+	// Extract interesting symbols from binary files in the profile and
+	// classify samples per symbol.
+	symbols := symbolsFromBinaries(rpt.prof, g, o.Symbol, address, obj)
+	symNodes := nodesPerSymbol(g.Nodes, symbols)
+
+	// Sort symbols for printing.
+	var syms objSymbols
+	for s := range symNodes {
+		syms = append(syms, s)
+	}
+	sort.Sort(syms)
+
+	if len(syms) == 0 {
+		return fmt.Errorf("no samples found on routines matching: %s", o.Symbol.String())
+	}
+
+	printHeader(w, rpt)
+	for _, s := range syms {
+		name := s.sym.Name[0]
+		// Identify sources associated to a symbol by examining
+		// symbol samples. Classify samples per source file.
+		var sourceFiles graph.Nodes
+		fileNodes := make(map[string]graph.Nodes)
+		for _, n := range symNodes[s] {
+			if n.Info.File == "" {
+				continue
+			}
+			if fileNodes[n.Info.File] == nil {
+				sourceFiles = append(sourceFiles, n)
+			}
+			fileNodes[n.Info.File] = append(fileNodes[n.Info.File], n)
+		}
+
+		if len(sourceFiles) == 0 {
+			fmt.Fprintf(w, "No source information for %s\n", name)
+			continue
+		}
+
+		sourceFiles.Sort(graph.FileOrder)
+
+		// Print each file associated with this function.
+		for _, fl := range sourceFiles {
+			filename := fl.Info.File
+			fns := fileNodes[filename]
+
+			asm := assemblyPerSourceLine(symbols, fns, filename, obj)
+			start, end := sourceCoordinates(asm)
+
+			fnodes, path, err := getFunctionSource(name, filename, fns, start, end)
+			if err != nil {
+				fnodes, path = getMissingFunctionSource(filename, asm, start, end)
+			}
+
+			flatSum, cumSum := fnodes.Sum()
+			printFunctionHeader(w, name, path, flatSum, cumSum, rpt)
+			for _, fn := range fnodes {
+				printFunctionSourceLine(w, fn, asm[fn.Info.Lineno], rpt)
+			}
+			printFunctionClosing(w)
+		}
+	}
+	printPageClosing(w)
+	return nil
+}
+
+// sourceCoordinates returns the lowest and highest line numbers from
+// a set of assembly statements.
+func sourceCoordinates(asm map[int]graph.Nodes) (start, end int) {
+	for l := range asm {
+		if start == 0 || l < start {
+			start = l
+		}
+		if end == 0 || l > end {
+			end = l
+		}
+	}
+	return 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]graph.Nodes {
+	assembly := make(map[int]graph.Nodes)
+	// Identify symbol to use for this collection of samples.
+	o := findMatchingSymbol(objSyms, rs)
+	if o == nil {
+		return assembly
+	}
+
+	// Extract assembly for matched symbol
+	insns, 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)
+	var lineno = 0
+	for _, an := range anodes {
+		if filepath.Base(an.Info.File) == srcBase {
+			lineno = an.Info.Lineno
+		}
+		if lineno != 0 {
+			assembly[lineno] = append(assembly[lineno], an)
+		}
+	}
+
+	return assembly
+}
+
+// findMatchingSymbol looks for the symbol that corresponds to a set
+// of samples, by comparing their addresses.
+func findMatchingSymbol(objSyms []*objSymbol, ns graph.Nodes) *objSymbol {
+	for _, n := range ns {
+		for _, o := range objSyms {
+			if filepath.Base(o.sym.File) == n.Info.Objfile &&
+				o.sym.Start <= n.Info.Address-o.base &&
+				n.Info.Address-o.base <= o.sym.End {
+				return o
+			}
+		}
+	}
+	return nil
+}
+
+// printHeader prints the page header for a weblist report.
+func printHeader(w io.Writer, rpt *Report) {
+	fmt.Fprintln(w, weblistPageHeader)
+
+	var labels []string
+	for _, l := range ProfileLabels(rpt) {
+		labels = append(labels, template.HTMLEscapeString(l))
+	}
+
+	fmt.Fprintf(w, `<div class="legend">%s<br>Total: %s</div>`,
+		strings.Join(labels, "<br>\n"),
+		rpt.formatValue(rpt.total),
+	)
+}
+
+// printFunctionHeader prints a function header for a weblist report.
+func printFunctionHeader(w io.Writer, name, path string, flatSum, cumSum int64, rpt *Report) {
+	fmt.Fprintf(w, `<h1>%s</h1>%s
+<pre onClick="pprof_toggle_asm()">
+  Total:  %10s %10s (flat, cum) %s
+`,
+		template.HTMLEscapeString(name), template.HTMLEscapeString(path),
+		rpt.formatValue(flatSum), rpt.formatValue(cumSum),
+		percentage(cumSum, rpt.total))
+}
+
+// printFunctionSourceLine prints a source line and the corresponding assembly.
+func printFunctionSourceLine(w io.Writer, fn *graph.Node, assembly graph.Nodes, rpt *Report) {
+	if len(assembly) == 0 {
+		fmt.Fprintf(w,
+			"<span class=line> %6d</span> <span class=nop>  %10s %10s %s </span>\n",
+			fn.Info.Lineno,
+			valueOrDot(fn.Flat, rpt), valueOrDot(fn.Cum, rpt),
+			template.HTMLEscapeString(fn.Info.Name))
+		return
+	}
+
+	fmt.Fprintf(w,
+		"<span class=line> %6d</span> <span class=deadsrc>  %10s %10s %s </span>",
+		fn.Info.Lineno,
+		valueOrDot(fn.Flat, rpt), valueOrDot(fn.Cum, rpt),
+		template.HTMLEscapeString(fn.Info.Name))
+	fmt.Fprint(w, "<span class=asm>")
+	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 {
+				class = "unimportant"
+			}
+		}
+		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),
+			class,
+			template.HTMLEscapeString(fileline))
+	}
+	fmt.Fprintln(w, "</span>")
+}
+
+// printFunctionClosing prints the end of a function in a weblist report.
+func printFunctionClosing(w io.Writer) {
+	fmt.Fprintln(w, "</pre>")
+}
+
+// printPageClosing prints the end of the page in a weblist report.
+func printPageClosing(w io.Writer) {
+	fmt.Fprintln(w, weblistPageClosing)
+}
+
+// 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)
+	if err != nil {
+		return nil, file, err
+	}
+
+	lineNodes := make(map[int]graph.Nodes)
+	// Collect source coordinates from profile.
+	const margin = 5 // Lines before first/after last sample.
+	if start == 0 {
+		if fns[0].Info.StartLine != 0 {
+			start = fns[0].Info.StartLine
+		} else {
+			start = fns[0].Info.Lineno - margin
+		}
+	} else {
+		start -= margin
+	}
+	if end == 0 {
+		end = fns[0].Info.Lineno
+	}
+	end += margin
+	for _, n := range fns {
+		lineno := n.Info.Lineno
+		nodeStart := n.Info.StartLine
+		if nodeStart == 0 {
+			nodeStart = lineno - margin
+		}
+		nodeEnd := lineno + margin
+		if nodeStart < start {
+			start = nodeStart
+		} else if nodeEnd > end {
+			end = nodeEnd
+		}
+		lineNodes[lineno] = append(lineNodes[lineno], n)
+	}
+
+	var src graph.Nodes
+	buf := bufio.NewReader(f)
+	lineno := 1
+	for {
+		line, err := buf.ReadString('\n')
+		if err != nil {
+			if err != io.EOF {
+				return nil, file, err
+			}
+			if line == "" {
+				break
+			}
+		}
+		if lineno >= start {
+			flat, cum := lineNodes[lineno].Sum()
+
+			src = append(src, &graph.Node{
+				Info: graph.NodeInfo{
+					Name:   strings.TrimRight(line, "\n"),
+					Lineno: lineno,
+				},
+				Flat: flat,
+				Cum:  cum,
+			})
+		}
+		lineno++
+		if lineno > end {
+			break
+		}
+	}
+	return src, file, nil
+}
+
+// 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) {
+	var fnodes graph.Nodes
+	for i := start; i <= end; i++ {
+		lrs := asm[i]
+		if len(lrs) == 0 {
+			continue
+		}
+		flat, cum := lrs.Sum()
+		fnodes = append(fnodes, &graph.Node{
+			Info: graph.NodeInfo{
+				Name:   "???",
+				Lineno: i,
+			},
+			Flat: flat,
+			Cum:  cum,
+		})
+	}
+	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) {
+	path = trimPath(path)
+	f, err := os.Open(path)
+	if err == nil {
+		return f, path, nil
+	}
+
+	if dir, wderr := os.Getwd(); wderr == nil {
+		for {
+			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
+}
+
+// trimPath cleans up a path by removing prefixes that are commonly
+// found on profiles.
+func trimPath(path string) string {
+	basePaths := []string{
+		"/proc/self/cwd/./",
+		"/proc/self/cwd/",
+	}
+
+	sPath := filepath.ToSlash(path)
+
+	for _, base := range basePaths {
+		if strings.HasPrefix(sPath, base) {
+			return filepath.FromSlash(sPath[len(base):])
+		}
+	}
+	return path
+}

src/internal/report/source_html.go

+// 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.
+
+package report
+
+const weblistPageHeader = `
+<!DOCTYPE html>
+<html>
+<head>
+<title>Pprof listing</title>
+<style type="text/css">
+body {
+font-family: sans-serif;
+}
+h1 {
+  font-size: 1.5em;
+  margin-bottom: 4px;
+}
+.legend {
+  font-size: 1.25em;
+}
+.line {
+color: #aaaaaa;
+}
+.nop {
+color: #aaaaaa;
+}
+.unimportant {
+color: #cccccc;
+}
+.disasmloc {
+color: #000000;
+}
+.deadsrc {
+cursor: pointer;
+}
+.deadsrc:hover {
+background-color: #eeeeee;
+}
+.livesrc {
+color: #0000ff;
+cursor: pointer;
+}
+.livesrc:hover {
+background-color: #eeeeee;
+}
+.asm {
+color: #008800;
+display: none;
+}
+</style>
+<script type="text/javascript">
+function pprof_toggle_asm(e) {
+  var target;
+  if (!e) e = window.event;
+  if (e.target) target = e.target;
+  else if (e.srcElement) target = e.srcElement;
+
+  if (target) {
+    var asm = target.nextSibling;
+    if (asm && asm.className == "asm") {
+      asm.style.display = (asm.style.display == "block" ? "" : "block");
+      e.preventDefault();
+      return false;
+    }
+  }
+}
+</script>
+</head>
+<body>
+`
+
+const weblistPageClosing = `
+</body>
+</html>
+`

src/internal/report/testdata/source.dot

+digraph "." {
+node [style=filled fillcolor="#f8f8f8"]
+subgraph cluster_L { "Duration: 10s, Total samples = 11111 " [shape=box fontsize=16 label="Duration: 10s, Total samples = 11111 \lShowing nodes accounting for 11111, 100% of 11111 total\l"] }
+N1 [label="tee\nsource2:8\n10000 (90.00%)" fontsize=24 shape=box tooltip="tee testdata/source2:8 (10000)" color="#b20500" fillcolor="#edd6d5"]
+N2 [label="main\nsource1:2\n1 (0.009%)\nof 11111 (100%)" fontsize=9 shape=box tooltip="main testdata/source1:2 (11111)" color="#b20000" fillcolor="#edd5d5"]
+N3 [label="tee\nsource2:2\n1000 (9.00%)\nof 11000 (99.00%)" fontsize=14 shape=box tooltip="tee testdata/source2:2 (11000)" color="#b20000" fillcolor="#edd5d5"]
+N4 [label="tee\nsource2:8\n100 (0.9%)" fontsize=10 shape=box tooltip="tee testdata/source2:8 (100)" color="#b2b0aa" fillcolor="#edecec"]
+N5 [label="bar\nsource1:10\n10 (0.09%)" fontsize=9 shape=box tooltip="bar testdata/source1:10 (10)" color="#b2b2b1" fillcolor="#ededed"]
+N6 [label="bar\nsource1:10\n0 of 100 (0.9%)" fontsize=8 shape=box tooltip="bar testdata/source1:10 (100)" color="#b2b0aa" fillcolor="#edecec"]
+N7 [label="foo\nsource1:4\n0 of 10 (0.09%)" fontsize=8 shape=box tooltip="foo testdata/source1:4 (10)" color="#b2b2b1" fillcolor="#ededed"]
+N2 -> N3 [label=" 11000" weight=100 penwidth=5 color="#b20000" tooltip="main testdata/source1:2 -> tee testdata/source2:2 (11000)" labeltooltip="main testdata/source1:2 -> tee testdata/source2:2 (11000)"]
+N3 -> N1 [label=" 10000" weight=91 penwidth=5 color="#b20500" tooltip="tee testdata/source2:2 -> tee testdata/source2:8 (10000)" labeltooltip="tee testdata/source2:2 -> tee testdata/source2:8 (10000)"]
+N6 -> N4 [label=" 100" color="#b2b0aa" tooltip="bar testdata/source1:10 -> tee testdata/source2:8 (100)" labeltooltip="bar testdata/source1:10 -> tee testdata/source2:8 (100)"]
+N2 -> N6 [label=" 100" color="#b2b0aa" tooltip="main testdata/source1:2 -> bar testdata/source1:10 (100)" labeltooltip="main testdata/source1:2 -> bar testdata/source1:10 (100)"]
+N7 -> N5 [label=" 10" color="#b2b2b1" tooltip="foo testdata/source1:4 -> bar testdata/source1:10 (10)" labeltooltip="foo testdata/source1:4 -> bar testdata/source1:10 (10)"]
+N2 -> N7 [label=" 10" color="#b2b2b1" tooltip="main testdata/source1:2 -> foo testdata/source1:4 (10)" labeltooltip="main testdata/source1:2 -> foo testdata/source1:4 (10)"]
+}

src/internal/report/testdata/source.rpt

+Total: 11111
+ROUTINE ======================== bar in testdata/source1
+        10        110 (flat, cum)  0.99% of Total
+         .          .      5:source1 line 5;
+         .          .      6:source1 line 6;
+         .          .      7:source1 line 7;
+         .          .      8:source1 line 8;
+         .          .      9:source1 line 9;
+        10        110     10:source1 line 10;
+         .          .     11:source1 line 11;
+         .          .     12:source1 line 12;
+         .          .     13:source1 line 13;
+         .          .     14:source1 line 14;
+         .          .     15:source1 line 15;
+ROUTINE ======================== foo in testdata/source1
+         0         10 (flat, cum)  0.09% of Total
+         .          .      1:source1 line 1;
+         .          .      2:source1 line 2;
+         .          .      3:source1 line 3;
+         .         10      4:source1 line 4;
+         .          .      5:source1 line 5;
+         .          .      6:source1 line 6;
+         .          .      7:source1 line 7;
+         .          .      8:source1 line 8;
+         .          .      9:source1 line 9;
+ROUTINE ======================== main in testdata/source1
+         1      11111 (flat, cum)   100% of Total
+         .          .      1:source1 line 1;
+         1      11111      2:source1 line 2;
+         .          .      3:source1 line 3;
+         .          .      4:source1 line 4;
+         .          .      5:source1 line 5;
+         .          .      6:source1 line 6;
+         .          .      7:source1 line 7;
+ROUTINE ======================== tee in testdata/source2
+     11100      21100 (flat, cum) 189.90% of Total
+         .          .      1:source2 line 1;
+      1000      11000      2:source2 line 2;
+         .          .      3:source2 line 3;
+         .          .      4:source2 line 4;
+         .          .      5:source2 line 5;
+         .          .      6:source2 line 6;
+         .          .      7:source2 line 7;
+     10100      10100      8:source2 line 8;
+         .          .      9:source2 line 9;
+         .          .     10:source2 line 10;
+         .          .     11:source2 line 11;
+         .          .     12:source2 line 12;
+         .          .     13:source2 line 13;

src/internal/report/testdata/source1

+source1 line 1;
+source1 line 2;
+source1 line 3;
+source1 line 4;
+source1 line 5;
+source1 line 6;
+source1 line 7;
+source1 line 8;
+source1 line 9;
+source1 line 10;
+source1 line 11;
+source1 line 12;
+source1 line 13;
+source1 line 14;
+source1 line 15;
+source1 line 16;
+source1 line 17;
+source1 line 18;
+

src/internal/report/testdata/source2

+source2 line 1;
+source2 line 2;
+source2 line 3;
+source2 line 4;
+source2 line 5;
+source2 line 6;
+source2 line 7;
+source2 line 8;
+source2 line 9;
+source2 line 10;
+source2 line 11;
+source2 line 12;
+source2 line 13;
+source2 line 14;
+source2 line 15;
+source2 line 16;
+source2 line 17;
+source2 line 18;
+

src/internal/symbolizer/symbolizer.go

+// 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.
+
+// Package symbolizer provides a routine to populate a profile with
+// symbol, file and line number information. It relies on the
+// addr2liner and demangle packages to do the actual work.
+package symbolizer
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"path/filepath"
+	"strings"
+
+	"internal/binutils"
+	"internal/plugin"
+	"profile"
+	"internal/symbolz"
+	"golang/demangle"
+)
+
+// Symbolizer implements the plugin.Symbolize interface.
+type Symbolizer struct {
+	Obj plugin.ObjTool
+	UI  plugin.UI
+}
+
+// Symbolize attempts to symbolize profile p. First uses binutils on
+// local binaries; if the source is a URL it attempts to get any
+// missed entries using symbolz.
+func (s *Symbolizer) Symbolize(mode string, sources plugin.MappingSources, p *profile.Profile) error {
+	remote, local, force, demanglerMode := true, true, false, ""
+	for _, o := range strings.Split(strings.ToLower(mode), ":") {
+		switch o {
+		case "none", "no":
+			return nil
+		case "local", "fastlocal":
+			remote, local = false, true
+		case "remote":
+			remote, local = true, false
+		case "", "force":
+			force = true
+		default:
+			switch d := strings.TrimPrefix(o, "demangle="); d {
+			case "full", "none", "templates":
+				demanglerMode = d
+				force = true
+				continue
+			case "default":
+				continue
+			}
+			s.UI.PrintErr("ignoring unrecognized symbolization option: " + mode)
+			s.UI.PrintErr("expecting -symbolize=[local|fastlocal|remote|none][:force][:demangle=[none|full|templates|default]")
+		}
+	}
+
+	var err error
+	if local {
+		// Symbolize locally using binutils.
+		if err = localSymbolize(mode, p, s.Obj, s.UI); err == nil {
+			remote = false // Already symbolized, no need to apply remote symbolization.
+		}
+	}
+	if remote {
+		if err = symbolz.Symbolize(sources, postURL, p, s.UI); err != nil {
+			return err // Ran out of options.
+		}
+	}
+
+	Demangle(p, force, demanglerMode)
+	return nil
+}
+
+// postURL issues a POST to a URL over HTTP.
+func postURL(source, post string) ([]byte, error) {
+	resp, err := http.Post(source, "application/octet-stream", strings.NewReader(post))
+	if err != nil {
+		return nil, fmt.Errorf("http post %s: %v", source, err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("server response: %s", resp.Status)
+	}
+	defer resp.Body.Close()
+	return ioutil.ReadAll(resp.Body)
+}
+
+// localSymbolize adds symbol and line number information to all locations
+// in a profile. mode enables some options to control
+// symbolization.
+func localSymbolize(mode string, prof *profile.Profile, obj plugin.ObjTool, ui plugin.UI) error {
+	force := false
+	// Disable some mechanisms based on mode string.
+	for _, o := range strings.Split(strings.ToLower(mode), ":") {
+		switch {
+		case o == "force":
+			force = true
+		case o == "fastlocal":
+			if bu, ok := obj.(*binutils.Binutils); ok {
+				bu.SetFastSymbolization(true)
+			}
+		default:
+		}
+	}
+
+	mt, err := newMapping(prof, obj, ui, force)
+	if err != nil {
+		return err
+	}
+	defer mt.close()
+
+	functions := make(map[profile.Function]*profile.Function)
+	for _, l := range mt.prof.Location {
+		m := l.Mapping
+		segment := mt.segments[m]
+		if segment == nil {
+			// Nothing to do.
+			continue
+		}
+
+		stack, err := segment.SourceLine(l.Address)
+		if err != nil || len(stack) == 0 {
+			// No answers from addr2line.
+			continue
+		}
+
+		l.Line = make([]profile.Line, len(stack))
+		for i, frame := range stack {
+			if frame.Func != "" {
+				m.HasFunctions = true
+			}
+			if frame.File != "" {
+				m.HasFilenames = true
+			}
+			if frame.Line != 0 {
+				m.HasLineNumbers = true
+			}
+			f := &profile.Function{
+				Name:       frame.Func,
+				SystemName: frame.Func,
+				Filename:   frame.File,
+			}
+			if fp := functions[*f]; fp != nil {
+				f = fp
+			} else {
+				functions[*f] = f
+				f.ID = uint64(len(mt.prof.Function)) + 1
+				mt.prof.Function = append(mt.prof.Function, f)
+			}
+			l.Line[i] = profile.Line{
+				Function: f,
+				Line:     int64(frame.Line),
+			}
+		}
+
+		if len(stack) > 0 {
+			m.HasInlineFrames = true
+		}
+	}
+
+	return nil
+}
+
+// Demangle updates the function names in a profile with demangled C++
+// names, simplified according to demanglerMode. If force is set,
+// overwrite any names that appear already demangled.
+func Demangle(prof *profile.Profile, force bool, demanglerMode string) {
+	if force {
+		// Remove the current demangled names to force demangling
+		for _, f := range prof.Function {
+			if f.Name != "" && f.SystemName != "" {
+				f.Name = f.SystemName
+			}
+		}
+	}
+
+	var options []demangle.Option
+	switch demanglerMode {
+	case "": // demangled, simplified: no parameters, no templates, no return type
+		options = []demangle.Option{demangle.NoParams, demangle.NoTemplateParams}
+	case "templates": // demangled, simplified: no parameters, no return type
+		options = []demangle.Option{demangle.NoParams}
+	case "full":
+		options = []demangle.Option{demangle.NoClones}
+	case "none": // no demangling
+		return
+	}
+
+	// Copy the options because they may be updated by the call.
+	o := make([]demangle.Option, len(options))
+	for _, fn := range prof.Function {
+		if fn.Name != "" && fn.SystemName != fn.Name {
+			continue // Already demangled.
+		}
+		copy(o, options)
+		if demangled := demangle.Filter(fn.SystemName, o...); demangled != fn.SystemName {
+			fn.Name = demangled
+			continue
+		}
+		// Could not demangle. Apply heuristics in case the name is
+		// already demangled.
+		name := fn.SystemName
+		if looksLikeDemangledCPlusPlus(name) {
+			if demanglerMode == "" || demanglerMode == "templates" {
+				name = removeMatching(name, '(', ')')
+			}
+			if demanglerMode == "" {
+				name = removeMatching(name, '<', '>')
+			}
+		}
+		fn.Name = name
+	}
+}
+
+// looksLikeDemangledCPlusPlus is a heuristic to decide if a name is
+// the result of demangling C++. If so, further heuristics will be
+// applied to simplify the name.
+func looksLikeDemangledCPlusPlus(demangled string) bool {
+	if strings.Contains(demangled, ".<") { // Skip java names of the form "class.<init>"
+		return false
+	}
+	return strings.ContainsAny(demangled, "<>[]") || strings.Contains(demangled, "::")
+}
+
+// removeMatching removes nested instances of start..end from name.
+func removeMatching(name string, start, end byte) string {
+	s := string(start) + string(end)
+	var nesting, first, current int
+	for index := strings.IndexAny(name[current:], s); index != -1; index = strings.IndexAny(name[current:], s) {
+		switch current += index; name[current] {
+		case start:
+			nesting++
+			if nesting == 1 {
+				first = current
+			}
+		case end:
+			nesting--
+			switch {
+			case nesting < 0:
+				return name // Mismatch, abort
+			case nesting == 0:
+				name = name[:first] + name[current+1:]
+				current = first - 1
+			}
+		}
+		current++
+	}
+	return name
+}
+
+// newMapping creates a mappingTable for a profile.
+func newMapping(prof *profile.Profile, obj plugin.ObjTool, ui plugin.UI, force bool) (*mappingTable, error) {
+	mt := &mappingTable{
+		prof:     prof,
+		segments: make(map[*profile.Mapping]plugin.ObjFile),
+	}
+
+	// Identify used mappings
+	mappings := make(map[*profile.Mapping]bool)
+	for _, l := range prof.Location {
+		mappings[l.Mapping] = true
+	}
+
+	for _, m := range prof.Mapping {
+		if !mappings[m] {
+			continue
+		}
+
+		// Do not attempt to re-symbolize a mapping that has already been symbolized.
+		if !force && (m.HasFunctions || m.HasFilenames || m.HasLineNumbers) {
+			continue
+		}
+
+		// Skip well-known system mappings
+		name := filepath.Base(m.File)
+		if name == "" || name == "[vdso]" || strings.HasPrefix(name, "linux-vdso") {
+			continue
+		}
+
+		f, err := obj.Open(m.File, m.Start, m.Limit, m.Offset)
+		if err != nil {
+			ui.PrintErr("Local symbolization failed for ", name, ": ", err)
+			continue
+		}
+		if fid := f.BuildID(); m.BuildID != "" && fid != "" && fid != m.BuildID {
+			ui.PrintErr("Local symbolization failed for ", name, ": build ID mismatch")
+			f.Close()
+			continue
+		}
+
+		mt.segments[m] = f
+	}
+
+	return mt, nil
+}
+
+// mappingTable contains the mechanisms for symbolization of a
+// profile.
+type mappingTable struct {
+	prof     *profile.Profile
+	segments map[*profile.Mapping]plugin.ObjFile
+}
+
+// Close releases any external processes being used for the mapping.
+func (mt *mappingTable) close() {
+	for _, segment := range mt.segments {
+		segment.Close()
+	}
+}

src/internal/symbolizer/symbolizer_test.go

+// 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.
+
+package symbolizer
+
+import (
+	"fmt"
+	"regexp"
+	"testing"
+
+	"internal/plugin"
+	"profile"
+	"internal/proftest"
+)
+
+var testM = []*profile.Mapping{
+	{
+		ID:    1,
+		Start: 0x1000,
+		Limit: 0x5000,
+	},
+}
+
+var testL = []*profile.Location{
+	{
+		ID:      1,
+		Mapping: testM[0],
+		Address: 1000,
+	},
+	{
+		ID:      2,
+		Mapping: testM[0],
+		Address: 2000,
+	},
+	{
+		ID:      3,
+		Mapping: testM[0],
+		Address: 3000,
+	},
+	{
+		ID:      4,
+		Mapping: testM[0],
+		Address: 4000,
+	},
+	{
+		ID:      5,
+		Mapping: testM[0],
+		Address: 5000,
+	},
+}
+
+var testProfile = profile.Profile{
+	DurationNanos: 10e9,
+	SampleType: []*profile.ValueType{
+		{Type: "cpu", Unit: "cycles"},
+	},
+	Sample: []*profile.Sample{
+		{
+			Location: []*profile.Location{testL[0]},
+			Value:    []int64{1},
+		},
+		{
+			Location: []*profile.Location{testL[1], testL[0]},
+			Value:    []int64{10},
+		},
+		{
+			Location: []*profile.Location{testL[2], testL[0]},
+			Value:    []int64{100},
+		},
+		{
+			Location: []*profile.Location{testL[3], testL[0]},
+			Value:    []int64{1},
+		},
+		{
+			Location: []*profile.Location{testL[4], testL[3], testL[0]},
+			Value:    []int64{10000},
+		},
+	},
+	Location:   testL,
+	Mapping:    testM,
+	PeriodType: &profile.ValueType{Type: "cpu", Unit: "milliseconds"},
+	Period:     10,
+}
+
+func TestSymbolization(t *testing.T) {
+	prof := testProfile
+
+	if prof.HasFunctions() {
+		t.Error("unexpected function names")
+	}
+	if prof.HasFileLines() {
+		t.Error("unexpected filenames or line numbers")
+	}
+
+	b := mockObjTool{}
+	if err := localSymbolize("", &prof, b, &proftest.TestUI{T: t}); err != nil {
+		t.Fatalf("Symbolize(): %v", err)
+	}
+
+	for _, loc := range prof.Location {
+		if err := checkSymbolizedLocation(loc.Address, loc.Line); err != nil {
+			t.Errorf("location %d: %v", loc.Address, err)
+		}
+	}
+	if !prof.HasFunctions() {
+		t.Error("missing function names")
+	}
+	if !prof.HasFileLines() {
+		t.Error("missing filenames or line numbers")
+	}
+}
+
+func checkSymbolizedLocation(a uint64, got []profile.Line) error {
+	want, ok := mockAddresses[a]
+	if !ok {
+		return fmt.Errorf("unexpected address")
+	}
+	if len(want) != len(got) {
+		return fmt.Errorf("want len %d, got %d", len(want), len(got))
+	}
+
+	for i, w := range want {
+		g := got[i]
+		if g.Function.Name != w.Func {
+			return fmt.Errorf("want function: %q, got %q", w.Func, g.Function.Name)
+		}
+		if g.Function.Filename != w.File {
+			return fmt.Errorf("want filename: %q, got %q", w.File, g.Function.Filename)
+		}
+		if g.Line != int64(w.Line) {
+			return fmt.Errorf("want lineno: %d, got %d", w.Line, g.Line)
+		}
+	}
+	return nil
+}
+
+var mockAddresses = map[uint64][]plugin.Frame{
+	1000: []plugin.Frame{{"fun11", "file11.src", 10}},
+	2000: []plugin.Frame{{"fun21", "file21.src", 20}, {"fun22", "file22.src", 20}},
+	3000: []plugin.Frame{{"fun31", "file31.src", 30}, {"fun32", "file32.src", 30}, {"fun33", "file33.src", 30}},
+	4000: []plugin.Frame{{"fun41", "file41.src", 40}, {"fun42", "file42.src", 40}, {"fun43", "file43.src", 40}, {"fun44", "file44.src", 40}},
+	5000: []plugin.Frame{{"fun51", "file51.src", 50}, {"fun52", "file52.src", 50}, {"fun53", "file53.src", 50}, {"fun54", "file54.src", 50}, {"fun55", "file55.src", 50}},
+}
+
+type mockObjTool struct{}
+
+func (mockObjTool) Open(file string, start, limit, offset uint64) (plugin.ObjFile, error) {
+	return mockObjFile{frames: mockAddresses}, nil
+}
+
+func (mockObjTool) Disasm(file string, start, end uint64) ([]plugin.Inst, error) {
+	return nil, fmt.Errorf("disassembly not supported")
+}
+
+type mockObjFile struct {
+	frames map[uint64][]plugin.Frame
+}
+
+func (mockObjFile) Name() string {
+	return ""
+}
+
+func (mockObjFile) Base() uint64 {
+	return 0
+}
+
+func (mockObjFile) BuildID() string {
+	return ""
+}
+
+func (mf mockObjFile) SourceLine(addr uint64) ([]plugin.Frame, error) {
+	return mf.frames[addr], nil
+}
+
+func (mockObjFile) Symbols(r *regexp.Regexp, addr uint64) ([]*plugin.Sym, error) {
+	return []*plugin.Sym{}, nil
+}
+
+func (mockObjFile) Close() error {
+	return nil
+}

src/internal/symbolz/symbolz.go

+// 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.
+
+// Package symbolz symbolizes a profile using the output from the symbolz
+// service.
+package symbolz
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"net/url"
+	"path"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"internal/plugin"
+	"profile"
+)
+
+var (
+	symbolzRE = regexp.MustCompile(`(0x[[:xdigit:]]+)\s+(.*)`)
+)
+
+// Symbolize symbolizes profile p by parsing data returned by a
+// symbolz handler. syms receives the symbolz query (hex addresses
+// separated by '+') and returns the symbolz output in a string.  It
+// symbolizes all locations based on their addresses, regardless of
+// mapping.
+func Symbolize(sources plugin.MappingSources, syms func(string, string) ([]byte, error), p *profile.Profile, ui plugin.UI) error {
+	for _, m := range p.Mapping {
+		if m.HasFunctions {
+			continue
+		}
+		mappingSources := sources[m.File]
+		if m.BuildID != "" {
+			mappingSources = append(mappingSources, sources[m.BuildID]...)
+		}
+		for _, source := range mappingSources {
+			if symz := symbolz(source.Source); symz != "" {
+				if err := symbolizeMapping(symz, int64(source.Start)-int64(m.Start), syms, m, p); err != nil {
+					return err
+				}
+				m.HasFunctions = true
+				break
+			}
+		}
+	}
+
+	return nil
+}
+
+// symbolz returns the corresponding symbolz source for a profile URL.
+func symbolz(source string) string {
+	if url, err := url.Parse(source); err == nil && url.Host != "" {
+		if strings.Contains(url.Path, "/") {
+			if dir := path.Dir(url.Path); dir == "/debug/pprof" {
+				// For Go language profile handlers in net/http/pprof package.
+				url.Path = "/debug/pprof/symbol"
+			} else {
+				url.Path = "/symbolz"
+			}
+			url.RawQuery = ""
+			return url.String()
+		}
+	}
+
+	return ""
+}
+
+// symbolizeMapping symbolizes locations belonging to a Mapping by querying
+// a symbolz handler. An offset is applied to all addresses to take care of
+// normalization occured for merged Mappings.
+func symbolizeMapping(source string, offset int64, syms func(string, string) ([]byte, error), m *profile.Mapping, p *profile.Profile) error {
+	// Construct query of addresses to symbolize.
+	var a []string
+	for _, l := range p.Location {
+		if l.Mapping == m && l.Address != 0 && len(l.Line) == 0 {
+			// Compensate for normalization.
+			addr := int64(l.Address) + offset
+			if addr < 0 {
+				return fmt.Errorf("unexpected negative adjusted address, mapping %v source %d, offset %d", l.Mapping, l.Address, offset)
+			}
+			a = append(a, fmt.Sprintf("%#x", addr))
+		}
+	}
+
+	if len(a) == 0 {
+		// No addresses to symbolize.
+		return nil
+	}
+
+	lines := make(map[uint64]profile.Line)
+	functions := make(map[string]*profile.Function)
+
+	b, err := syms(source, strings.Join(a, "+"))
+	if err != nil {
+		return err
+	}
+
+	buf := bytes.NewBuffer(b)
+	for {
+		l, err := buf.ReadString('\n')
+
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+
+		if symbol := symbolzRE.FindStringSubmatch(l); len(symbol) == 3 {
+			addr, err := strconv.ParseInt(symbol[1], 0, 64)
+			if err != nil {
+				return fmt.Errorf("unexpected parse failure %s: %v", symbol[1], err)
+			}
+			if addr < 0 {
+				return fmt.Errorf("unexpected negative adjusted address, source %s, offset %d", symbol[1], offset)
+			}
+			// Reapply offset expected by the profile.
+			addr -= offset
+
+			name := symbol[2]
+			fn := functions[name]
+			if fn == nil {
+				fn = &profile.Function{
+					ID:         uint64(len(p.Function) + 1),
+					Name:       name,
+					SystemName: name,
+				}
+				functions[name] = fn
+				p.Function = append(p.Function, fn)
+			}
+
+			lines[uint64(addr)] = profile.Line{Function: fn}
+		}
+	}
+
+	for _, l := range p.Location {
+		if l.Mapping != m {
+			continue
+		}
+		if line, ok := lines[l.Address]; ok {
+			l.Line = []profile.Line{line}
+		}
+	}
+
+	return nil
+}

src/internal/symbolz/symbolz_test.go

+// 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.
+
+package symbolz
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"internal/plugin"
+	"profile"
+	"internal/proftest"
+)
+
+func TestSymbolzURL(t *testing.T) {
+	for try, want := range map[string]string{
+		"http://host:8000/profilez":                        "http://host:8000/symbolz",
+		"http://host:8000/profilez?seconds=5":              "http://host:8000/symbolz",
+		"http://host:8000/profilez?seconds=5&format=proto": "http://host:8000/symbolz",
+		"http://host:8000/heapz?format=legacy":             "http://host:8000/symbolz",
+		"http://host:8000/debug/pprof/profile":             "http://host:8000/debug/pprof/symbol",
+		"http://host:8000/debug/pprof/profile?seconds=10":  "http://host:8000/debug/pprof/symbol",
+		"http://host:8000/debug/pprof/heap":                "http://host:8000/debug/pprof/symbol",
+	} {
+		if got := symbolz(try); got != want {
+			t.Errorf(`symbolz(%s)=%s, want "%s"`, try, got, want)
+		}
+	}
+}
+
+func TestSymbolize(t *testing.T) {
+	m := []*profile.Mapping{
+		{
+			ID:      1,
+			Start:   0x1000,
+			Limit:   0x5000,
+			BuildID: "buildid",
+		},
+	}
+	p := &profile.Profile{
+		Location: []*profile.Location{
+			{ID: 1, Mapping: m[0], Address: 0x1000},
+			{ID: 2, Mapping: m[0], Address: 0x2000},
+			{ID: 3, Mapping: m[0], Address: 0x3000},
+			{ID: 4, Mapping: m[0], Address: 0x4000},
+		},
+		Mapping: m,
+	}
+
+	s := plugin.MappingSources{
+		"buildid": []struct {
+			Source string
+			Start  uint64
+		}{
+			{Source: "http://localhost:80/profilez"},
+		},
+	}
+
+	if err := Symbolize(s, fetchSymbols, p, &proftest.TestUI{T: t}); err != nil {
+		t.Errorf("symbolz: %v", err)
+	}
+
+	if l := p.Location[0]; len(l.Line) != 0 {
+		t.Errorf("unexpected symbolization for %#x: %v", l.Address, l.Line)
+	}
+
+	for _, l := range p.Location[1:] {
+		if len(l.Line) != 1 {
+			t.Errorf("failed to symbolize %#x", l.Address)
+			continue
+		}
+		address := l.Address - l.Mapping.Start
+		if got, want := l.Line[0].Function.Name, fmt.Sprintf("%#x", address); got != want {
+			t.Errorf("symbolz %#x, got %s, want %s", address, got, want)
+		}
+	}
+}
+
+func fetchSymbols(source, post string) ([]byte, error) {
+	var symbolz string
+
+	addresses := strings.Split(post, "+")
+	// Do not symbolize the first symbol.
+	for _, address := range addresses[1:] {
+		symbolz += fmt.Sprintf("%s\t%s\n", address, address)
+	}
+	return []byte(symbolz), nil
+}

src/pprof/pprof.go

+// 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.
+
+// pprof is a tool for collection, manipulation and visualization
+// of performance profiles.
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"driver"
+)
+
+func main() {
+	if err := driver.PProf(&driver.Options{}); err != nil {
+		fmt.Fprintf(os.Stderr, "pprof: %v\n", err)
+	}
+}

src/profile/encode.go

+// 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.
+
+package profile
+
+import (
+	"errors"
+	"fmt"
+	"sort"
+)
+
+func (p *Profile) decoder() []decoder {
+	return profileDecoder
+}
+
+// preEncode populates the unexported fields to be used by encode
+// (with suffix X) from the corresponding exported fields.  The
+// exported fields are cleared up to facilitate testing.
+func (p *Profile) preEncode() {
+	strings := make(map[string]int)
+	addString(strings, "")
+
+	for _, st := range p.SampleType {
+		st.typeX = addString(strings, st.Type)
+		st.unitX = addString(strings, st.Unit)
+	}
+
+	for _, s := range p.Sample {
+		s.labelX = nil
+		var keys []string
+		for k := range s.Label {
+			keys = append(keys, k)
+		}
+		sort.Strings(keys)
+		for _, k := range keys {
+			vs := s.Label[k]
+			for _, v := range vs {
+				s.labelX = append(s.labelX,
+					label{
+						keyX: addString(strings, k),
+						strX: addString(strings, v),
+					},
+				)
+			}
+		}
+		var numKeys []string
+		for k := range s.NumLabel {
+			numKeys = append(numKeys, k)
+		}
+		sort.Strings(numKeys)
+		for _, k := range numKeys {
+			vs := s.NumLabel[k]
+			for _, v := range vs {
+				s.labelX = append(s.labelX,
+					label{
+						keyX: addString(strings, k),
+						numX: v,
+					},
+				)
+			}
+		}
+		s.locationIDX = nil
+		for _, l := range s.Location {
+			s.locationIDX = append(s.locationIDX, l.ID)
+		}
+	}
+
+	for _, m := range p.Mapping {
+		m.fileX = addString(strings, m.File)
+		m.buildIDX = addString(strings, m.BuildID)
+	}
+
+	for _, l := range p.Location {
+		for i, ln := range l.Line {
+			if ln.Function != nil {
+				l.Line[i].functionIDX = ln.Function.ID
+			} else {
+				l.Line[i].functionIDX = 0
+			}
+		}
+		if l.Mapping != nil {
+			l.mappingIDX = l.Mapping.ID
+		} else {
+			l.mappingIDX = 0
+		}
+	}
+	for _, f := range p.Function {
+		f.nameX = addString(strings, f.Name)
+		f.systemNameX = addString(strings, f.SystemName)
+		f.filenameX = addString(strings, f.Filename)
+	}
+
+	p.dropFramesX = addString(strings, p.DropFrames)
+	p.keepFramesX = addString(strings, p.KeepFrames)
+
+	if pt := p.PeriodType; pt != nil {
+		pt.typeX = addString(strings, pt.Type)
+		pt.unitX = addString(strings, pt.Unit)
+	}
+
+	p.commentX = nil
+	for _, c := range p.Comments {
+		p.commentX = append(p.commentX, addString(strings, c))
+	}
+
+	p.stringTable = make([]string, len(strings))
+	for s, i := range strings {
+		p.stringTable[i] = s
+	}
+}
+
+func (p *Profile) encode(b *buffer) {
+	for _, x := range p.SampleType {
+		encodeMessage(b, 1, x)
+	}
+	for _, x := range p.Sample {
+		encodeMessage(b, 2, x)
+	}
+	for _, x := range p.Mapping {
+		encodeMessage(b, 3, x)
+	}
+	for _, x := range p.Location {
+		encodeMessage(b, 4, x)
+	}
+	for _, x := range p.Function {
+		encodeMessage(b, 5, x)
+	}
+	encodeStrings(b, 6, p.stringTable)
+	encodeInt64Opt(b, 7, p.dropFramesX)
+	encodeInt64Opt(b, 8, p.keepFramesX)
+	encodeInt64Opt(b, 9, p.TimeNanos)
+	encodeInt64Opt(b, 10, p.DurationNanos)
+	if pt := p.PeriodType; pt != nil && (pt.typeX != 0 || pt.unitX != 0) {
+		encodeMessage(b, 11, p.PeriodType)
+	}
+	encodeInt64Opt(b, 12, p.Period)
+	encodeInt64s(b, 13, p.commentX)
+}
+
+var profileDecoder = []decoder{
+	nil, // 0
+	// repeated ValueType sample_type = 1
+	func(b *buffer, m message) error {
+		x := new(ValueType)
+		pp := m.(*Profile)
+		pp.SampleType = append(pp.SampleType, x)
+		return decodeMessage(b, x)
+	},
+	// repeated Sample sample = 2
+	func(b *buffer, m message) error {
+		x := new(Sample)
+		pp := m.(*Profile)
+		pp.Sample = append(pp.Sample, x)
+		return decodeMessage(b, x)
+	},
+	// repeated Mapping mapping = 3
+	func(b *buffer, m message) error {
+		x := new(Mapping)
+		pp := m.(*Profile)
+		pp.Mapping = append(pp.Mapping, x)
+		return decodeMessage(b, x)
+	},
+	// repeated Location location = 4
+	func(b *buffer, m message) error {
+		x := new(Location)
+		pp := m.(*Profile)
+		pp.Location = append(pp.Location, x)
+		return decodeMessage(b, x)
+	},
+	// repeated Function function = 5
+	func(b *buffer, m message) error {
+		x := new(Function)
+		pp := m.(*Profile)
+		pp.Function = append(pp.Function, x)
+		return decodeMessage(b, x)
+	},
+	// repeated string string_table = 6
+	func(b *buffer, m message) error {
+		err := decodeStrings(b, &m.(*Profile).stringTable)
+		if err != nil {
+			return err
+		}
+		if *&m.(*Profile).stringTable[0] != "" {
+			return errors.New("string_table[0] must be ''")
+		}
+		return nil
+	},
+	// int64 drop_frames = 7
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).dropFramesX) },
+	// int64 keep_frames = 8
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).keepFramesX) },
+	// int64 time_nanos = 9
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).TimeNanos) },
+	// int64 duration_nanos = 10
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).DurationNanos) },
+	// ValueType period_type = 11
+	func(b *buffer, m message) error {
+		x := new(ValueType)
+		pp := m.(*Profile)
+		pp.PeriodType = x
+		return decodeMessage(b, x)
+	},
+	// int64 period = 12
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Profile).Period) },
+	// repeated int64 comment = 13
+	func(b *buffer, m message) error { return decodeInt64s(b, &m.(*Profile).commentX) },
+}
+
+// postDecode takes the unexported fields populated by decode (with
+// suffix X) and populates the corresponding exported fields.
+// The unexported fields are cleared up to facilitate testing.
+func (p *Profile) postDecode() error {
+	var err error
+	mappings := make(map[uint64]*Mapping)
+	for _, m := range p.Mapping {
+		m.File, err = getString(p.stringTable, &m.fileX, err)
+		m.BuildID, err = getString(p.stringTable, &m.buildIDX, err)
+		mappings[m.ID] = m
+	}
+
+	functions := make(map[uint64]*Function)
+	for _, f := range p.Function {
+		f.Name, err = getString(p.stringTable, &f.nameX, err)
+		f.SystemName, err = getString(p.stringTable, &f.systemNameX, err)
+		f.Filename, err = getString(p.stringTable, &f.filenameX, err)
+		functions[f.ID] = f
+	}
+
+	locations := make(map[uint64]*Location)
+	for _, l := range p.Location {
+		l.Mapping = mappings[l.mappingIDX]
+		l.mappingIDX = 0
+		for i, ln := range l.Line {
+			if id := ln.functionIDX; id != 0 {
+				l.Line[i].Function = functions[id]
+				if l.Line[i].Function == nil {
+					return fmt.Errorf("Function ID %d not found", id)
+				}
+				l.Line[i].functionIDX = 0
+			}
+		}
+		locations[l.ID] = l
+	}
+
+	for _, st := range p.SampleType {
+		st.Type, err = getString(p.stringTable, &st.typeX, err)
+		st.Unit, err = getString(p.stringTable, &st.unitX, err)
+	}
+
+	for _, s := range p.Sample {
+		labels := make(map[string][]string)
+		numLabels := make(map[string][]int64)
+		for _, l := range s.labelX {
+			var key, value string
+			key, err = getString(p.stringTable, &l.keyX, err)
+			if l.strX != 0 {
+				value, err = getString(p.stringTable, &l.strX, err)
+				labels[key] = append(labels[key], value)
+			} else if l.numX != 0 {
+				numLabels[key] = append(numLabels[key], l.numX)
+			}
+		}
+		if len(labels) > 0 {
+			s.Label = labels
+		}
+		if len(numLabels) > 0 {
+			s.NumLabel = numLabels
+		}
+		s.Location = nil
+		for _, lid := range s.locationIDX {
+			s.Location = append(s.Location, locations[lid])
+		}
+		s.locationIDX = nil
+	}
+
+	p.DropFrames, err = getString(p.stringTable, &p.dropFramesX, err)
+	p.KeepFrames, err = getString(p.stringTable, &p.keepFramesX, err)
+
+	if pt := p.PeriodType; pt == nil {
+		p.PeriodType = &ValueType{}
+	}
+
+	if pt := p.PeriodType; pt != nil {
+		pt.Type, err = getString(p.stringTable, &pt.typeX, err)
+		pt.Unit, err = getString(p.stringTable, &pt.unitX, err)
+	}
+
+	for _, i := range p.commentX {
+		var c string
+		c, err = getString(p.stringTable, &i, err)
+		p.Comments = append(p.Comments, c)
+	}
+
+	p.commentX = nil
+	p.stringTable = nil
+	return err
+}
+
+func (p *ValueType) decoder() []decoder {
+	return valueTypeDecoder
+}
+
+func (p *ValueType) encode(b *buffer) {
+	encodeInt64Opt(b, 1, p.typeX)
+	encodeInt64Opt(b, 2, p.unitX)
+}
+
+var valueTypeDecoder = []decoder{
+	nil, // 0
+	// optional int64 type = 1
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*ValueType).typeX) },
+	// optional int64 unit = 2
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*ValueType).unitX) },
+}
+
+func (p *Sample) decoder() []decoder {
+	return sampleDecoder
+}
+
+func (p *Sample) encode(b *buffer) {
+	encodeUint64s(b, 1, p.locationIDX)
+	encodeInt64s(b, 2, p.Value)
+	for _, x := range p.labelX {
+		encodeMessage(b, 3, x)
+	}
+}
+
+var sampleDecoder = []decoder{
+	nil, // 0
+	// repeated uint64 location = 1
+	func(b *buffer, m message) error { return decodeUint64s(b, &m.(*Sample).locationIDX) },
+	// repeated int64 value = 2
+	func(b *buffer, m message) error { return decodeInt64s(b, &m.(*Sample).Value) },
+	// repeated Label label = 3
+	func(b *buffer, m message) error {
+		s := m.(*Sample)
+		n := len(s.labelX)
+		s.labelX = append(s.labelX, label{})
+		return decodeMessage(b, &s.labelX[n])
+	},
+}
+
+func (p label) decoder() []decoder {
+	return labelDecoder
+}
+
+func (p label) encode(b *buffer) {
+	encodeInt64Opt(b, 1, p.keyX)
+	encodeInt64Opt(b, 2, p.strX)
+	encodeInt64Opt(b, 3, p.numX)
+}
+
+var labelDecoder = []decoder{
+	nil, // 0
+	// optional int64 key = 1
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*label).keyX) },
+	// optional int64 str = 2
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*label).strX) },
+	// optional int64 num = 3
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*label).numX) },
+}
+
+func (p *Mapping) decoder() []decoder {
+	return mappingDecoder
+}
+
+func (p *Mapping) encode(b *buffer) {
+	encodeUint64Opt(b, 1, p.ID)
+	encodeUint64Opt(b, 2, p.Start)
+	encodeUint64Opt(b, 3, p.Limit)
+	encodeUint64Opt(b, 4, p.Offset)
+	encodeInt64Opt(b, 5, p.fileX)
+	encodeInt64Opt(b, 6, p.buildIDX)
+	encodeBoolOpt(b, 7, p.HasFunctions)
+	encodeBoolOpt(b, 8, p.HasFilenames)
+	encodeBoolOpt(b, 9, p.HasLineNumbers)
+	encodeBoolOpt(b, 10, p.HasInlineFrames)
+}
+
+var mappingDecoder = []decoder{
+	nil, // 0
+	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Mapping).ID) },            // optional uint64 id = 1
+	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Mapping).Start) },         // optional uint64 memory_offset = 2
+	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Mapping).Limit) },         // optional uint64 memory_limit = 3
+	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Mapping).Offset) },        // optional uint64 file_offset = 4
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Mapping).fileX) },          // optional int64 filename = 5
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Mapping).buildIDX) },       // optional int64 build_id = 6
+	func(b *buffer, m message) error { return decodeBool(b, &m.(*Mapping).HasFunctions) },    // optional bool has_functions = 7
+	func(b *buffer, m message) error { return decodeBool(b, &m.(*Mapping).HasFilenames) },    // optional bool has_filenames = 8
+	func(b *buffer, m message) error { return decodeBool(b, &m.(*Mapping).HasLineNumbers) },  // optional bool has_line_numbers = 9
+	func(b *buffer, m message) error { return decodeBool(b, &m.(*Mapping).HasInlineFrames) }, // optional bool has_inline_frames = 10
+}
+
+func (p *Location) decoder() []decoder {
+	return locationDecoder
+}
+
+func (p *Location) encode(b *buffer) {
+	encodeUint64Opt(b, 1, p.ID)
+	encodeUint64Opt(b, 2, p.mappingIDX)
+	encodeUint64Opt(b, 3, p.Address)
+	for i := range p.Line {
+		encodeMessage(b, 4, &p.Line[i])
+	}
+}
+
+var locationDecoder = []decoder{
+	nil, // 0
+	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Location).ID) },         // optional uint64 id = 1;
+	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Location).mappingIDX) }, // optional uint64 mapping_id = 2;
+	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Location).Address) },    // optional uint64 address = 3;
+	func(b *buffer, m message) error { // repeated Line line = 4
+		pp := m.(*Location)
+		n := len(pp.Line)
+		pp.Line = append(pp.Line, Line{})
+		return decodeMessage(b, &pp.Line[n])
+	},
+}
+
+func (p *Line) decoder() []decoder {
+	return lineDecoder
+}
+
+func (p *Line) encode(b *buffer) {
+	encodeUint64Opt(b, 1, p.functionIDX)
+	encodeInt64Opt(b, 2, p.Line)
+}
+
+var lineDecoder = []decoder{
+	nil, // 0
+	// optional uint64 function_id = 1
+	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Line).functionIDX) },
+	// optional int64 line = 2
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Line).Line) },
+}
+
+func (p *Function) decoder() []decoder {
+	return functionDecoder
+}
+
+func (p *Function) encode(b *buffer) {
+	encodeUint64Opt(b, 1, p.ID)
+	encodeInt64Opt(b, 2, p.nameX)
+	encodeInt64Opt(b, 3, p.systemNameX)
+	encodeInt64Opt(b, 4, p.filenameX)
+	encodeInt64Opt(b, 5, p.StartLine)
+}
+
+var functionDecoder = []decoder{
+	nil, // 0
+	// optional uint64 id = 1
+	func(b *buffer, m message) error { return decodeUint64(b, &m.(*Function).ID) },
+	// optional int64 function_name = 2
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Function).nameX) },
+	// optional int64 function_system_name = 3
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Function).systemNameX) },
+	// repeated int64 filename = 4
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Function).filenameX) },
+	// optional int64 start_line = 5
+	func(b *buffer, m message) error { return decodeInt64(b, &m.(*Function).StartLine) },
+}
+
+func addString(strings map[string]int, s string) int64 {
+	i, ok := strings[s]
+	if !ok {
+		i = len(strings)
+		strings[s] = i
+	}
+	return int64(i)
+}
+
+func getString(strings []string, strng *int64, err error) (string, error) {
+	if err != nil {
+		return "", err
+	}
+	s := int(*strng)
+	if s < 0 || s >= len(strings) {
+		return "", errMalformed
+	}
+	*strng = 0
+	return strings[s], nil
+}

src/profile/filter.go

+// 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.
+
+package profile
+
+// Implements methods to filter samples from profiles.
+
+import "regexp"
+
+// FilterSamplesByName filters the samples in a profile and only keeps
+// samples where at least one frame matches focus but none match ignore.
+// Returns true is the corresponding regexp matched at least one sample.
+func (p *Profile) FilterSamplesByName(focus, ignore, hide, show *regexp.Regexp) (fm, im, hm, hnm bool) {
+	focusOrIgnore := make(map[uint64]bool)
+	hidden := make(map[uint64]bool)
+	for _, l := range p.Location {
+		if ignore != nil && l.matchesName(ignore) {
+			im = true
+			focusOrIgnore[l.ID] = false
+		} else if focus == nil || l.matchesName(focus) {
+			fm = true
+			focusOrIgnore[l.ID] = true
+		}
+
+		if hide != nil && l.matchesName(hide) {
+			hm = true
+			l.Line = l.unmatchedLines(hide)
+			if len(l.Line) == 0 {
+				hidden[l.ID] = true
+			}
+		}
+		if show != nil {
+			hnm = true
+			l.Line = l.matchedLines(show)
+			if len(l.Line) == 0 {
+				hidden[l.ID] = true
+			}
+		}
+	}
+
+	s := make([]*Sample, 0, len(p.Sample))
+	for _, sample := range p.Sample {
+		if focusedAndNotIgnored(sample.Location, focusOrIgnore) {
+			if len(hidden) > 0 {
+				var locs []*Location
+				for _, loc := range sample.Location {
+					if !hidden[loc.ID] {
+						locs = append(locs, loc)
+					}
+				}
+				if len(locs) == 0 {
+					// Remove sample with no locations (by not adding it to s).
+					continue
+				}
+				sample.Location = locs
+			}
+			s = append(s, sample)
+		}
+	}
+	p.Sample = s
+
+	return
+}
+
+// matchesName returns whether the location matches the regular
+// expression. It checks any available function names, file names, and
+// mapping object filename.
+func (loc *Location) matchesName(re *regexp.Regexp) bool {
+	for _, ln := range loc.Line {
+		if fn := ln.Function; fn != nil {
+			if re.MatchString(fn.Name) || re.MatchString(fn.Filename) {
+				return true
+			}
+		}
+	}
+	if m := loc.Mapping; m != nil && re.MatchString(m.File) {
+		return true
+	}
+	return false
+}
+
+// unmatchedLines returns the lines in the location that do not match
+// the regular expression.
+func (loc *Location) unmatchedLines(re *regexp.Regexp) []Line {
+	if m := loc.Mapping; m != nil && re.MatchString(m.File) {
+		return nil
+	}
+	var lines []Line
+	for _, ln := range loc.Line {
+		if fn := ln.Function; fn != nil {
+			if re.MatchString(fn.Name) || re.MatchString(fn.Filename) {
+				continue
+			}
+		}
+		lines = append(lines, ln)
+	}
+	return lines
+}
+
+// matchedLines returns the lines in the location that match
+// the regular expression.
+func (loc *Location) matchedLines(re *regexp.Regexp) []Line {
+	var lines []Line
+	for _, ln := range loc.Line {
+		if fn := ln.Function; fn != nil {
+			if !re.MatchString(fn.Name) && !re.MatchString(fn.Filename) {
+				continue
+			}
+		}
+		lines = append(lines, ln)
+	}
+	return lines
+}
+
+// focusedAndNotIgnored looks up a slice of ids against a map of
+// focused/ignored locations. The map only contains locations that are
+// explicitly focused or ignored. Returns whether there is at least
+// one focused location but no ignored locations.
+func focusedAndNotIgnored(locs []*Location, m map[uint64]bool) bool {
+	var f bool
+	for _, loc := range locs {
+		if focus, focusOrIgnore := m[loc.ID]; focusOrIgnore {
+			if focus {
+				// Found focused location. Must keep searching in case there
+				// is an ignored one as well.
+				f = true
+			} else {
+				// Found ignored location. Can return false right away.
+				return false
+			}
+		}
+	}
+	return f
+}
+
+// TagMatch selects tags for filtering
+type TagMatch func(s *Sample) bool
+
+// FilterSamplesByTag removes all samples from the profile, except
+// those that match focus and do not match the ignore regular
+// expression.
+func (p *Profile) FilterSamplesByTag(focus, ignore TagMatch) (fm, im bool) {
+	samples := make([]*Sample, 0, len(p.Sample))
+	for _, s := range p.Sample {
+		focused, ignored := true, false
+		if focus != nil {
+			focused = focus(s)
+		}
+		if ignore != nil {
+			ignored = ignore(s)
+		}
+		fm = fm || focused
+		im = im || ignored
+		if focused && !ignored {
+			samples = append(samples, s)
+		}
+	}
+	p.Sample = samples
+	return
+}

src/profile/legacy_java_profile.go

+// 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.
+
+// This file implements parsers to convert java legacy profiles into
+// the profile.proto format.
+
+package profile
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var (
+	attributeRx            = regexp.MustCompile(`([\w ]+)=([\w ]+)`)
+	javaSampleRx           = regexp.MustCompile(` *(\d+) +(\d+) +@ +([ x0-9a-f]*)`)
+	javaLocationRx         = regexp.MustCompile(`^\s*0x([[:xdigit:]]+)\s+(.*)\s*$`)
+	javaLocationFileLineRx = regexp.MustCompile(`^(.*)\s+\((.+):(-?[[:digit:]]+)\)$`)
+	javaLocationPathRx     = regexp.MustCompile(`^(.*)\s+\((.*)\)$`)
+)
+
+// javaCPUProfile returns a new Profile from profilez data.
+// b is the profile bytes after the header, period is the profiling
+// period, and parse is a function to parse 8-byte chunks from the
+// profile in its native endianness.
+func javaCPUProfile(b []byte, period int64, parse func(b []byte) (uint64, []byte)) (*Profile, error) {
+	p := &Profile{
+		Period:     period * 1000,
+		PeriodType: &ValueType{Type: "cpu", Unit: "nanoseconds"},
+		SampleType: []*ValueType{{Type: "samples", Unit: "count"}, {Type: "cpu", Unit: "nanoseconds"}},
+	}
+	var err error
+	var locs map[uint64]*Location
+	if b, locs, err = parseCPUSamples(b, parse, false, p); err != nil {
+		return nil, err
+	}
+
+	if err = parseJavaLocations(b, locs, p); err != nil {
+		return nil, err
+	}
+
+	// Strip out addresses for better merge.
+	if err = p.Aggregate(true, true, true, true, false); err != nil {
+		return nil, err
+	}
+
+	return p, nil
+}
+
+// parseJavaProfile returns a new profile from heapz or contentionz
+// data. b is the profile bytes after the header.
+func parseJavaProfile(b []byte) (*Profile, error) {
+	h := bytes.SplitAfterN(b, []byte("\n"), 2)
+	if len(h) < 2 {
+		return nil, errUnrecognized
+	}
+
+	p := &Profile{
+		PeriodType: &ValueType{},
+	}
+	header := string(bytes.TrimSpace(h[0]))
+
+	var err error
+	var pType string
+	switch header {
+	case "--- heapz 1 ---":
+		pType = "heap"
+	case "--- contentionz 1 ---":
+		pType = "contention"
+	default:
+		return nil, errUnrecognized
+	}
+
+	if b, err = parseJavaHeader(pType, h[1], p); err != nil {
+		return nil, err
+	}
+	var locs map[uint64]*Location
+	if b, locs, err = parseJavaSamples(pType, b, p); err != nil {
+		return nil, err
+	}
+	if err = parseJavaLocations(b, locs, p); err != nil {
+		return nil, err
+	}
+
+	// Strip out addresses for better merge.
+	if err = p.Aggregate(true, true, true, true, false); err != nil {
+		return nil, err
+	}
+
+	return p, nil
+}
+
+// parseJavaHeader parses the attribute section on a java profile and
+// populates a profile. Returns the remainder of the buffer after all
+// attributes.
+func parseJavaHeader(pType string, b []byte, p *Profile) ([]byte, error) {
+	nextNewLine := bytes.IndexByte(b, byte('\n'))
+	for nextNewLine != -1 {
+		line := string(bytes.TrimSpace(b[0:nextNewLine]))
+		if line != "" {
+			h := attributeRx.FindStringSubmatch(line)
+			if h == nil {
+				// Not a valid attribute, exit.
+				return b, nil
+			}
+
+			attribute, value := strings.TrimSpace(h[1]), strings.TrimSpace(h[2])
+			var err error
+			switch pType + "/" + attribute {
+			case "heap/format", "cpu/format", "contention/format":
+				if value != "java" {
+					return nil, errUnrecognized
+				}
+			case "heap/resolution":
+				p.SampleType = []*ValueType{
+					{Type: "inuse_objects", Unit: "count"},
+					{Type: "inuse_space", Unit: value},
+				}
+			case "contention/resolution":
+				p.SampleType = []*ValueType{
+					{Type: "contentions", Unit: value},
+					{Type: "delay", Unit: value},
+				}
+			case "contention/sampling period":
+				p.PeriodType = &ValueType{
+					Type: "contentions", Unit: "count",
+				}
+				if p.Period, err = strconv.ParseInt(value, 0, 64); err != nil {
+					return nil, fmt.Errorf("failed to parse attribute %s: %v", line, err)
+				}
+			case "contention/ms since reset":
+				millis, err := strconv.ParseInt(value, 0, 64)
+				if err != nil {
+					return nil, fmt.Errorf("failed to parse attribute %s: %v", line, err)
+				}
+				p.DurationNanos = millis * 1000 * 1000
+			default:
+				return nil, errUnrecognized
+			}
+		}
+		// Grab next line.
+		b = b[nextNewLine+1:]
+		nextNewLine = bytes.IndexByte(b, byte('\n'))
+	}
+	return b, nil
+}
+
+// parseJavaSamples parses the samples from a java profile and
+// populates the Samples in a profile. Returns the remainder of the
+// buffer after the samples.
+func parseJavaSamples(pType string, b []byte, p *Profile) ([]byte, map[uint64]*Location, error) {
+	nextNewLine := bytes.IndexByte(b, byte('\n'))
+	locs := make(map[uint64]*Location)
+	for nextNewLine != -1 {
+		line := string(bytes.TrimSpace(b[0:nextNewLine]))
+		if line != "" {
+			sample := javaSampleRx.FindStringSubmatch(line)
+			if sample == nil {
+				// Not a valid sample, exit.
+				return b, locs, nil
+			}
+
+			// Java profiles have data/fields inverted compared to other
+			// profile types.
+			value1, value2, addrs := sample[2], sample[1], sample[3]
+
+			var sloc []*Location
+			for _, addr := range parseHexAddresses(addrs) {
+				loc := locs[addr]
+				if locs[addr] == nil {
+					loc = &Location{
+						Address: addr,
+					}
+					p.Location = append(p.Location, loc)
+					locs[addr] = loc
+				}
+				sloc = append(sloc, loc)
+			}
+			s := &Sample{
+				Value:    make([]int64, 2),
+				Location: sloc,
+			}
+
+			var err error
+			if s.Value[0], err = strconv.ParseInt(value1, 0, 64); err != nil {
+				return nil, nil, fmt.Errorf("parsing sample %s: %v", line, err)
+			}
+			if s.Value[1], err = strconv.ParseInt(value2, 0, 64); err != nil {
+				return nil, nil, fmt.Errorf("parsing sample %s: %v", line, err)
+			}
+
+			switch pType {
+			case "heap":
+				const javaHeapzSamplingRate = 524288 // 512K
+				s.NumLabel = map[string][]int64{"bytes": []int64{s.Value[1] / s.Value[0]}}
+				s.Value[0], s.Value[1] = scaleHeapSample(s.Value[0], s.Value[1], javaHeapzSamplingRate)
+			case "contention":
+				if period := p.Period; period != 0 {
+					s.Value[0] = s.Value[0] * p.Period
+					s.Value[1] = s.Value[1] * p.Period
+				}
+			}
+			p.Sample = append(p.Sample, s)
+		}
+		// Grab next line.
+		b = b[nextNewLine+1:]
+		nextNewLine = bytes.IndexByte(b, byte('\n'))
+	}
+	return b, locs, nil
+}
+
+// parseJavaLocations parses the location information in a java
+// profile and populates the Locations in a profile. It uses the
+// location addresses from the profile as both the ID of each
+// location.
+func parseJavaLocations(b []byte, locs map[uint64]*Location, p *Profile) error {
+	r := bytes.NewBuffer(b)
+	fns := make(map[string]*Function)
+	for {
+		line, err := r.ReadString('\n')
+		if err != nil {
+			if err != io.EOF {
+				return err
+			}
+			if line == "" {
+				break
+			}
+		}
+
+		if line = strings.TrimSpace(line); line == "" {
+			continue
+		}
+
+		jloc := javaLocationRx.FindStringSubmatch(line)
+		if len(jloc) != 3 {
+			continue
+		}
+		addr, err := strconv.ParseUint(jloc[1], 16, 64)
+		if err != nil {
+			return fmt.Errorf("parsing sample %s: %v", line, err)
+		}
+		loc := locs[addr]
+		if loc == nil {
+			// Unused/unseen
+			continue
+		}
+		var lineFunc, lineFile string
+		var lineNo int64
+
+		if fileLine := javaLocationFileLineRx.FindStringSubmatch(jloc[2]); len(fileLine) == 4 {
+			// Found a line of the form: "function (file:line)"
+			lineFunc, lineFile = fileLine[1], fileLine[2]
+			if n, err := strconv.ParseInt(fileLine[3], 10, 64); err == nil && n > 0 {
+				lineNo = n
+			}
+		} else if filePath := javaLocationPathRx.FindStringSubmatch(jloc[2]); len(filePath) == 3 {
+			// If there's not a file:line, it's a shared library path.
+			// The path isn't interesting, so just give the .so.
+			lineFunc, lineFile = filePath[1], filepath.Base(filePath[2])
+		} else if strings.Contains(jloc[2], "generated stub/JIT") {
+			lineFunc = "STUB"
+		} else {
+			// Treat whole line as the function name. This is used by the
+			// java agent for internal states such as "GC" or "VM".
+			lineFunc = jloc[2]
+		}
+		fn := fns[lineFunc]
+
+		if fn == nil {
+			fn = &Function{
+				Name:       lineFunc,
+				SystemName: lineFunc,
+				Filename:   lineFile,
+			}
+			fns[lineFunc] = fn
+			p.Function = append(p.Function, fn)
+		}
+		loc.Line = []Line{
+			{
+				Function: fn,
+				Line:     lineNo,
+			},
+		}
+		loc.Address = 0
+	}
+
+	p.remapLocationIDs()
+	p.remapFunctionIDs()
+	p.remapMappingIDs()
+
+	return nil
+}