cmd/pprof: update vendored github.com/google/pprof

Pull in the latest published version of github.com/google/pprof
as part of #36905.

This adds the fmt.Println redundant newline fix from
google/pprof@f987b9c94b318d4bd026dcc7892f7f1fab6eadab.

Done with:

	go get -d github.com/google/pprof@latest
	go mod tidy
	go mod vendor

For #36905.
Fixes #49322.

Change-Id: Ia832766bba65a30c68407b73b33fefbe81438e65
Reviewed-on: https://go-review.googlesource.com/c/go/+/361294
Trust: Dmitri Shuralyov <dmitshur@golang.org>
Trust: Zvonimir Pavlinovic <zpavlinovic@google.com>
Run-TryBot: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Zvonimir Pavlinovic <zpavlinovic@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Zvonimir Pavlinovic <zpavlinovic@google.com>

2 files changed, 63 insertions, 45 deletions

diff --git a/src/cmd/vendor/github.com/google/pprof/internal/elfexec/elfexec.go b/src/cmd/vendor/github.com/google/pprof/internal/elfexec/elfexec.go
index 4f11645185..6447092d3d 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/elfexec/elfexec.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/elfexec/elfexec.go
@@ -165,19 +165,61 @@ func GetBuildID(binary io.ReaderAt) ([]byte, error) {
 	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) {
+// kernelBase caluclates the base for kernel mappings, which usually require
+// special handling. For kernel mappings, tools (like perf) use the address of
+// the kernel relocation symbol (_text or _stext) as the mmap start. Additionaly,
+// for obfuscation, ChromeOS profiles have the kernel image remapped to the 0-th page.
+func kernelBase(loadSegment *elf.ProgHeader, stextOffset *uint64, start, limit, offset uint64) (uint64, bool) {
 	const (
-		pageSize = 4096
 		// PAGE_OFFSET for PowerPC64, see arch/powerpc/Kconfig in the kernel sources.
 		pageOffsetPpc64 = 0xc000000000000000
+		pageSize        = 4096
 	)
 
+	if loadSegment.Vaddr == start-offset {
+		return offset, true
+	}
+	if start == 0 && limit != 0 && stextOffset != nil {
+		// ChromeOS remaps its kernel to 0. Nothing else should come
+		// down this path. Empirical values:
+		//       VADDR=0xffffffff80200000
+		// stextOffset=0xffffffff80200198
+		return start - *stextOffset, true
+	}
+	if start >= loadSegment.Vaddr && limit > start && (offset == 0 || offset == pageOffsetPpc64 || offset == start) {
+		// Some kernels look like:
+		//       VADDR=0xffffffff80200000
+		// stextOffset=0xffffffff80200198
+		//       Start=0xffffffff83200000
+		//       Limit=0xffffffff84200000
+		//      Offset=0 (0xc000000000000000 for PowerPC64) (== Start for ASLR kernel)
+		// 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 page
+			// alignment should be different from that of stextOffset.
+			return start - *stextOffset, true
+		}
+
+		return start - loadSegment.Vaddr, true
+	}
+	if 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 start - *stextOffset, true
+	}
+	return 0, false
+}
+
+// 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 needs special hanldling.
+func GetBase(fh *elf.FileHeader, loadSegment *elf.ProgHeader, stextOffset *uint64, start, limit, offset uint64) (uint64, error) {
+
 	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
@@ -202,43 +244,15 @@ func GetBase(fh *elf.FileHeader, loadSegment *elf.ProgHeader, stextOffset *uint6
 			// the 64-bit address space.
 			return start - offset + loadSegment.Off - loadSegment.Vaddr, nil
 		}
-		// Various kernel heuristics and cases follow.
-		if loadSegment.Vaddr == start-offset {
-			return offset, nil
+		// Various kernel heuristics and cases are handled separately.
+		if base, match := kernelBase(loadSegment, stextOffset, start, limit, offset); match {
+			return base, 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 start >= loadSegment.Vaddr && limit > start && (offset == 0 || offset == pageOffsetPpc64 || offset == start) {
-			// Some kernels look like:
-			//       VADDR=0xffffffff80200000
-			// stextOffset=0xffffffff80200198
-			//       Start=0xffffffff83200000
-			//       Limit=0xffffffff84200000
-			//      Offset=0 (0xc000000000000000 for PowerPC64) (== Start for ASLR kernel)
-			// 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 page
-				// alignment should be different from that of stextOffset.
-				return start - *stextOffset, nil
-			}
-
+		// ChromeOS can remap its kernel to 0, and the caller might have not found
+		// the _stext symbol. Split this case from kernelBase() above, since we don't
+		// want to apply it to an ET_DYN user-mode executable.
+		if start == 0 && limit != 0 && stextOffset == nil {
 			return start - loadSegment.Vaddr, nil
-		} else if 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 start - *stextOffset, 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)
@@ -255,6 +269,11 @@ func GetBase(fh *elf.FileHeader, loadSegment *elf.ProgHeader, stextOffset *uint6
 		if loadSegment == nil {
 			return start - offset, nil
 		}
+		// Kernels compiled as PIE can be ET_DYN as well. Use heuristic, similar to
+		// the ET_EXEC case above.
+		if base, match := kernelBase(loadSegment, stextOffset, start, limit, offset); match {
+			return base, nil
+		}
 		// The program header, if not nil, indicates the offset in the file where
 		// the executable segment is located (loadSegment.Off), and the base virtual
 		// address where the first byte of the segment is loaded
diff --git a/src/cmd/vendor/github.com/google/pprof/internal/report/source_html.go b/src/cmd/vendor/github.com/google/pprof/internal/report/source_html.go
index 17c9f6eb94..851693f1d0 100644
--- a/src/cmd/vendor/github.com/google/pprof/internal/report/source_html.go
+++ b/src/cmd/vendor/github.com/google/pprof/internal/report/source_html.go
@@ -72,5 +72,4 @@ function pprof_toggle_asm(e) {
 
 const weblistPageClosing = `
 </body>
-</html>
-`
+</html>`