Black Lives Matter. Support the Equal Justice Initiative.

Source file src/cmd/vendor/github.com/google/pprof/internal/binutils/addr2liner.go

Documentation: cmd/vendor/github.com/google/pprof/internal/binutils

     1  // Copyright 2014 Google Inc. All Rights Reserved.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package binutils
    16  
    17  import (
    18  	"bufio"
    19  	"fmt"
    20  	"io"
    21  	"os/exec"
    22  	"strconv"
    23  	"strings"
    24  	"sync"
    25  
    26  	"github.com/google/pprof/internal/plugin"
    27  )
    28  
    29  const (
    30  	defaultAddr2line = "addr2line"
    31  
    32  	// addr2line may produce multiple lines of output. We
    33  	// use this sentinel to identify the end of the output.
    34  	sentinel = ^uint64(0)
    35  )
    36  
    37  // addr2Liner is a connection to an addr2line command for obtaining
    38  // address and line number information from a binary.
    39  type addr2Liner struct {
    40  	mu   sync.Mutex
    41  	rw   lineReaderWriter
    42  	base uint64
    43  
    44  	// nm holds an addr2Liner using nm tool. Certain versions of addr2line
    45  	// produce incomplete names due to
    46  	// https://sourceware.org/bugzilla/show_bug.cgi?id=17541. As a workaround,
    47  	// the names from nm are used when they look more complete. See addrInfo()
    48  	// code below for the exact heuristic.
    49  	nm *addr2LinerNM
    50  }
    51  
    52  // lineReaderWriter is an interface to abstract the I/O to an addr2line
    53  // process. It writes a line of input to the job, and reads its output
    54  // one line at a time.
    55  type lineReaderWriter interface {
    56  	write(string) error
    57  	readLine() (string, error)
    58  	close()
    59  }
    60  
    61  type addr2LinerJob struct {
    62  	cmd *exec.Cmd
    63  	in  io.WriteCloser
    64  	out *bufio.Reader
    65  }
    66  
    67  func (a *addr2LinerJob) write(s string) error {
    68  	_, err := fmt.Fprint(a.in, s+"\n")
    69  	return err
    70  }
    71  
    72  func (a *addr2LinerJob) readLine() (string, error) {
    73  	return a.out.ReadString('\n')
    74  }
    75  
    76  // close releases any resources used by the addr2liner object.
    77  func (a *addr2LinerJob) close() {
    78  	a.in.Close()
    79  	a.cmd.Wait()
    80  }
    81  
    82  // newAddr2liner starts the given addr2liner command reporting
    83  // information about the given executable file. If file is a shared
    84  // library, base should be the address at which it was mapped in the
    85  // program under consideration.
    86  func newAddr2Liner(cmd, file string, base uint64) (*addr2Liner, error) {
    87  	if cmd == "" {
    88  		cmd = defaultAddr2line
    89  	}
    90  
    91  	j := &addr2LinerJob{
    92  		cmd: exec.Command(cmd, "-aif", "-e", file),
    93  	}
    94  
    95  	var err error
    96  	if j.in, err = j.cmd.StdinPipe(); err != nil {
    97  		return nil, err
    98  	}
    99  
   100  	outPipe, err := j.cmd.StdoutPipe()
   101  	if err != nil {
   102  		return nil, err
   103  	}
   104  
   105  	j.out = bufio.NewReader(outPipe)
   106  	if err := j.cmd.Start(); err != nil {
   107  		return nil, err
   108  	}
   109  
   110  	a := &addr2Liner{
   111  		rw:   j,
   112  		base: base,
   113  	}
   114  
   115  	return a, nil
   116  }
   117  
   118  func (d *addr2Liner) readString() (string, error) {
   119  	s, err := d.rw.readLine()
   120  	if err != nil {
   121  		return "", err
   122  	}
   123  	return strings.TrimSpace(s), nil
   124  }
   125  
   126  // readFrame parses the addr2line output for a single address. It
   127  // returns a populated plugin.Frame and whether it has reached the end of the
   128  // data.
   129  func (d *addr2Liner) readFrame() (plugin.Frame, bool) {
   130  	funcname, err := d.readString()
   131  	if err != nil {
   132  		return plugin.Frame{}, true
   133  	}
   134  	if strings.HasPrefix(funcname, "0x") {
   135  		// If addr2line returns a hex address we can assume it is the
   136  		// sentinel. Read and ignore next two lines of output from
   137  		// addr2line
   138  		d.readString()
   139  		d.readString()
   140  		return plugin.Frame{}, true
   141  	}
   142  
   143  	fileline, err := d.readString()
   144  	if err != nil {
   145  		return plugin.Frame{}, true
   146  	}
   147  
   148  	linenumber := 0
   149  
   150  	if funcname == "??" {
   151  		funcname = ""
   152  	}
   153  
   154  	if fileline == "??:0" {
   155  		fileline = ""
   156  	} else {
   157  		if i := strings.LastIndex(fileline, ":"); i >= 0 {
   158  			// Remove discriminator, if present
   159  			if disc := strings.Index(fileline, " (discriminator"); disc > 0 {
   160  				fileline = fileline[:disc]
   161  			}
   162  			// If we cannot parse a number after the last ":", keep it as
   163  			// part of the filename.
   164  			if line, err := strconv.Atoi(fileline[i+1:]); err == nil {
   165  				linenumber = line
   166  				fileline = fileline[:i]
   167  			}
   168  		}
   169  	}
   170  
   171  	return plugin.Frame{
   172  		Func: funcname,
   173  		File: fileline,
   174  		Line: linenumber}, false
   175  }
   176  
   177  func (d *addr2Liner) rawAddrInfo(addr uint64) ([]plugin.Frame, error) {
   178  	d.mu.Lock()
   179  	defer d.mu.Unlock()
   180  
   181  	if err := d.rw.write(fmt.Sprintf("%x", addr-d.base)); err != nil {
   182  		return nil, err
   183  	}
   184  
   185  	if err := d.rw.write(fmt.Sprintf("%x", sentinel)); err != nil {
   186  		return nil, err
   187  	}
   188  
   189  	resp, err := d.readString()
   190  	if err != nil {
   191  		return nil, err
   192  	}
   193  
   194  	if !strings.HasPrefix(resp, "0x") {
   195  		return nil, fmt.Errorf("unexpected addr2line output: %s", resp)
   196  	}
   197  
   198  	var stack []plugin.Frame
   199  	for {
   200  		frame, end := d.readFrame()
   201  		if end {
   202  			break
   203  		}
   204  
   205  		if frame != (plugin.Frame{}) {
   206  			stack = append(stack, frame)
   207  		}
   208  	}
   209  	return stack, err
   210  }
   211  
   212  // addrInfo returns the stack frame information for a specific program
   213  // address. It returns nil if the address could not be identified.
   214  func (d *addr2Liner) addrInfo(addr uint64) ([]plugin.Frame, error) {
   215  	stack, err := d.rawAddrInfo(addr)
   216  	if err != nil {
   217  		return nil, err
   218  	}
   219  
   220  	// Certain versions of addr2line produce incomplete names due to
   221  	// https://sourceware.org/bugzilla/show_bug.cgi?id=17541. Attempt to replace
   222  	// the name with a better one from nm.
   223  	if len(stack) > 0 && d.nm != nil {
   224  		nm, err := d.nm.addrInfo(addr)
   225  		if err == nil && len(nm) > 0 {
   226  			// Last entry in frame list should match since it is non-inlined. As a
   227  			// simple heuristic, we only switch to the nm-based name if it is longer
   228  			// by 2 or more characters. We consider nm names that are longer by 1
   229  			// character insignificant to avoid replacing foo with _foo on MacOS (for
   230  			// unknown reasons read2line produces the former and nm produces the
   231  			// latter on MacOS even though both tools are asked to produce mangled
   232  			// names).
   233  			nmName := nm[len(nm)-1].Func
   234  			a2lName := stack[len(stack)-1].Func
   235  			if len(nmName) > len(a2lName)+1 {
   236  				stack[len(stack)-1].Func = nmName
   237  			}
   238  		}
   239  	}
   240  
   241  	return stack, nil
   242  }
   243  

View as plain text