interpreter/golables: use .gopclntab for symbol lookup (open-telemetry#728)

Signed-off-by: Florian Lehner <florian.lehner@elastic.co>

Author: florianl

interpreter/apmint/apmint.go

@@ -19,7 +19,6 @@ import (
 	"go.opentelemetry.io/ebpf-profiler/host"
 	"go.opentelemetry.io/ebpf-profiler/interpreter"
 	"go.opentelemetry.io/ebpf-profiler/libpf"
-	"go.opentelemetry.io/ebpf-profiler/libpf/pfelf"
 	"go.opentelemetry.io/ebpf-profiler/remotememory"
 	"go.opentelemetry.io/ebpf-profiler/support"
 )
@@ -65,7 +64,7 @@ func Loader(_ interpreter.EbpfHandler, info *interpreter.LoaderInfo) (interprete
 	// Resolve process storage symbol.
 	procStorageSym, err := ef.LookupSymbol(procStorageExport)
 	if err != nil {
-		if errors.Is(err, pfelf.ErrSymbolNotFound) {
+		if errors.Is(err, libpf.ErrSymbolNotFound) {
 			// APM<->profiling integration not supported by agent.
 			return nil, nil
 		}

interpreter/golabels/tls_amd64.go

@@ -8,26 +8,27 @@ package golabels // import "go.opentelemetry.io/ebpf-profiler/interpreter/golabe
 import (
 	log "github.com/sirupsen/logrus"
 	"go.opentelemetry.io/ebpf-profiler/libpf/pfelf"
+	"go.opentelemetry.io/ebpf-profiler/nativeunwind/elfunwindinfo"
 	"golang.org/x/arch/x86/x86asm"
 )
 
 // Most normal amd64 Go binaries use -8 as offset into TLS space for
 // storing the current g but "static" binaries it ends up as -80. There
 // may be dynamic relocating going on so just read it from a known
 // symbol if possible.
-func extractTLSGOffset(f *pfelf.File, path string) (int32, error) {
-	syms, err := f.ReadSymbols()
+func extractTLSGOffset(f *pfelf.File) (int32, error) {
+	pclntab, err := elfunwindinfo.NewGopclntab(f)
 	if err != nil {
 		log.Debugf("Failed to find symbols (%v) using default TLSG offset", err)
 		return -8, nil
 	}
+	defer pclntab.Close()
+
 	// Dump of assembler code for function runtime.stackcheck:
 	// 0x0000000000470080 <+0>:     mov    %fs:0xfffffffffffffff8,%rax
-	sym, err := syms.LookupSymbol("runtime.stackcheck.abi0")
+	sym, err := pclntab.LookupSymbol("runtime.stackcheck")
 	if err != nil {
-		// Binary must be stripped, hope default is correct and warn.
-		log.Warnf("Failed to find stackcheck symbol, Go labels might not work: %v (%s)", err, path)
-		return -8, nil
+		return 0, err
 	}
 	b, err := f.VirtualMemory(int64(sym.Address), 16, 16)
 	if err != nil {

libpf/pfelf/file.go

@@ -51,9 +51,6 @@ const (
 
 // List of public errors.
 var (
-	// ErrSymbolNotFound is returned when the requested symbol was not found.
-	ErrSymbolNotFound = errors.New("symbol not found")
-
 	// ErrNotELF is returned when the file is not an ELF file.
 	ErrNotELF = errors.New("not an ELF file")
 )
@@ -1050,7 +1047,7 @@ func (f *File) LookupSymbol(symbol libpf.SymbolName) (*libpf.Symbol, error) {
 		mask := uint(1)<<(h%ptrSizeBits) |
 			uint(1)<<((h>>hdr.bloomShift)%ptrSizeBits)
 		if bloom&mask != mask {
-			return nil, ErrSymbolNotFound
+			return nil, libpf.ErrSymbolNotFound
 		}
 
 		// Read the initial symbol index to start looking from
@@ -1061,7 +1058,7 @@ func (f *File) LookupSymbol(symbol libpf.SymbolName) (*libpf.Symbol, error) {
 			return nil, err
 		}
 		if i == 0 {
-			return nil, ErrSymbolNotFound
+			return nil, libpf.ErrSymbolNotFound
 		}
 
 		// Search the hash bucket
@@ -1116,7 +1113,7 @@ func (f *File) LookupSymbol(symbol libpf.SymbolName) (*libpf.Symbol, error) {
 		return nil, errors.New("symbol hash not present")
 	}
 
-	return nil, ErrSymbolNotFound
+	return nil, libpf.ErrSymbolNotFound
 }
 
 // LookupSymbol searches for a given symbol in the ELF

libpf/symbol.go

@@ -4,11 +4,18 @@
 package libpf // import "go.opentelemetry.io/ebpf-profiler/libpf"
 
 import (
+	"errors"
 	"fmt"
 	"sort"
 	"strings"
 )
 
+// List of public errors.
+var (
+	// ErrSymbolNotFound is returned when the requested symbol was not found.
+	ErrSymbolNotFound = errors.New("symbol not found")
+)
+
 // SymbolValue represents the value associated with a symbol, e.g. either an
 // offset or an absolute address
 type SymbolValue uint64

nativeunwind/elfunwindinfo/elfgopclntab.go

@@ -17,6 +17,7 @@ import (
 	"strings"
 	"unsafe"
 
+	"go.opentelemetry.io/ebpf-profiler/libpf"
 	"go.opentelemetry.io/ebpf-profiler/libpf/pfelf"
 	sdtypes "go.opentelemetry.io/ebpf-profiler/nativeunwind/stackdeltatypes"
 	"go.opentelemetry.io/ebpf-profiler/support"
@@ -351,6 +352,30 @@ type Gopclntab struct {
 	functab, funcdata, funcnametab, filetab, pctab, cutab []byte
 }
 
+// LookupSymbol searches for a given symbol in .gopclntab.
+func (g *Gopclntab) LookupSymbol(symbol libpf.SymbolName) (*libpf.Symbol, error) {
+	symString := string(symbol)
+	for i := 0; i < g.numFuncs; i++ {
+		_, funcOff := g.getFuncMapEntry(i)
+		pc, fun := g.getFunc(funcOff)
+		if fun == nil {
+			continue
+		}
+		name := getString(g.funcnametab, int(fun.nameOff))
+		if name == symString {
+			nextPc, _ := g.getFuncMapEntry(i + 1)
+			size := uint64(nextPc - pc)
+
+			return &libpf.Symbol{
+				Name:    symbol,
+				Address: libpf.SymbolValue(pc),
+				Size:    size,
+			}, nil
+		}
+	}
+	return nil, libpf.ErrSymbolNotFound
+}
+
 // NewGopclntab parses and returns the parsed data for further operations.
 func NewGopclntab(ef *pfelf.File) (*Gopclntab, error) {
 	data, err := extractGoPclntab(ef)