Prefer nm based function names to addr2line based names.

The names produced by addr2line are often incomplete.  Fix this by
falling back to nm to get function names and using the nm-provided
name if it is longer.

internal/binutils/addr2liner.go

 type addr2Liner struct {
 	rw   lineReaderWriter
 	base uint64
+
+	// nm holds an NM based addr2Liner which can provide
+	// better full names compared to addr2line, which often drops
+	// namespaces etc. from the names it returns.
+	nm *addr2LinerNM
 }
 
 // lineReaderWriter is an interface to abstract the I/O to an addr2line
 			stack = append(stack, frame)
 		}
 	}
+
+	// Get better name from nm if possible.
+	if len(stack) > 0 && d.nm != nil {
+		nm, err := d.nm.addrInfo(addr)
+		if err == nil && len(nm) > 0 {
+			// Last entry in frame list should match since
+			// it is non-inlined.  As a simple heuristic,
+			// we only switch to the nm-based name if it
+			// is longer.
+			nmName := nm[len(nm)-1].Func
+			a2lName := stack[len(stack)-1].Func
+			if len(nmName) > len(a2lName) {
+				stack[len(stack)-1].Func = nmName
+			}
+		}
+	}
+
 	return stack, nil
 }

internal/binutils/binutils.go

 			return nil, err
 		}
 		f.addr2liner = addr2liner
+
+		// When addr2line encounters some gcc compiled binaries, it
+		// drops interesting parts of names in anonymous namespaces.
+		// Fallback to NM for better function names.
+		if nm, err := newAddr2LinerNM(f.b.nm, f.name, f.base); err == nil {
+			f.addr2liner.nm = nm
+		}
 	}
 	return f.addr2liner.addrInfo(addr)
 }

internal/binutils/binutils_test.go

 func TestAddr2Liner(t *testing.T) {
 	const offset = 0x500
 
-	a := addr2Liner{&mockAddr2liner{}, offset}
+	a := addr2Liner{&mockAddr2liner{}, offset, nil}
 	for i := 1; i < 8; i++ {
 		addr := i*0x1000 + offset
 		s, err := a.addrInfo(uint64(addr))