Allow passing options to Go symbolizer constructor

go/.golangci.yml

@@ -0,0 +1,5 @@
+version: "2"
+linters:
+  exclusions:
+    presets:
+      - std-error-handling

go/symbolizer.go

@@ -22,8 +22,15 @@ type Symbolizer struct {
 
 // NewSymbolizer creates an instance of a symbolizer.
 // See: https://docs.rs/blazesym-c/latest/blazesym_c/fn.blaze_symbolizer_new.html
-func NewSymbolizer() (*Symbolizer, error) {
-	s := C.blaze_symbolizer_new()
+func NewSymbolizer(options ...SymbolizerOption) (*Symbolizer, error) {
+	so := newSymbolizerOptions()
+	defer so.Close()
+
+	for _, option := range options {
+		option(so)
+	}
+
+	s := C.blaze_symbolizer_new_opts(&so.opts)
 	if s == nil {
 		return nil, blazeErr(C.blaze_err_last()).Error()
 	}

go/symbolizer_option.go

@@ -0,0 +1,108 @@
+package blazesym
+
+/*
+#cgo LDFLAGS: -lblazesym_c
+#include "blazesym.h"
+*/
+import "C"
+
+import (
+	"unsafe"
+)
+
+// SymbolizerOptions is options for configuring Symbolizer objects.
+// See: https://docs.rs/blazesym-c/latest/blazesym_c/struct.blaze_symbolizer_opts.html
+type SymbolizerOptions struct {
+	opts C.blaze_symbolizer_opts
+}
+
+func newSymbolizerOptions() *SymbolizerOptions {
+	opts := C.blaze_symbolizer_opts{}
+	opts.type_size = C.ulong(unsafe.Sizeof(opts))
+	opts.auto_reload = C.bool(true)
+	opts.code_info = C.bool(true)
+	opts.inlined_fns = C.bool(true)
+	opts.demangle = C.bool(true)
+
+	return &SymbolizerOptions{opts: opts}
+}
+
+// Close frees resources associated with SymbolizerOptions.
+func (so *SymbolizerOptions) Close() {
+	freeCArrayOfStrings(so.opts.debug_dirs, so.opts.debug_dirs_len)
+}
+
+// SymbolizerOption configures SymbolizerOptions objects.
+type SymbolizerOption func(*SymbolizerOptions)
+
+// WithDebugDirs sets the array of debug directories to search for split debug information.
+// See: https://docs.rs/blazesym-c/latest/blazesym_c/struct.blaze_symbolizer_opts.html#structfield.debug_dirs
+func WithDebugDirs(dirs []string) SymbolizerOption {
+	return func(so *SymbolizerOptions) {
+		if so.opts.debug_dirs_len != 0 {
+			freeCArrayOfStrings(so.opts.debug_dirs, so.opts.debug_dirs_len)
+		}
+
+		so.opts.debug_dirs = makeCArrayOfStrings(dirs)
+		so.opts.debug_dirs_len = C.size_t(len(dirs))
+	}
+}
+
+// WithAutoReload sets whether or not to automatically reload file system based
+// symbolization sources that were updated since the last symbolization operation.
+// See: https://docs.rs/blazesym-c/latest/blazesym_c/struct.blaze_symbolizer_opts.html#structfield.auto_reload
+func WithAutoReload(enabled bool) SymbolizerOption {
+	return func(so *SymbolizerOptions) {
+		so.opts.auto_reload = C.bool(enabled)
+	}
+}
+
+// WithCodeInfo sets whether to attempt to gather source code location information.
+// See: https://docs.rs/blazesym-c/latest/blazesym_c/struct.blaze_symbolizer_opts.html#structfield.code_info
+func WithCodeInfo(enabled bool) SymbolizerOption {
+	return func(so *SymbolizerOptions) {
+		so.opts.code_info = C.bool(enabled)
+	}
+}
+
+// WithInlinedFns sets whether to report inlined functions as part of symbolization.
+// See: https://docs.rs/blazesym-c/latest/blazesym_c/struct.blaze_symbolizer_opts.html#structfield.inlined_fns
+func WithInlinedFns(enabled bool) SymbolizerOption {
+	return func(so *SymbolizerOptions) {
+		so.opts.inlined_fns = C.bool(enabled)
+	}
+}
+
+// WithDemangle sets whether or not to transparently demangle symbols.
+// See: https://docs.rs/blazesym-c/latest/blazesym_c/struct.blaze_symbolizer_opts.html#structfield.demangle
+func WithDemangle(enabled bool) SymbolizerOption {
+	return func(so *SymbolizerOptions) {
+		so.opts.demangle = C.bool(enabled)
+	}
+}
+
+func makeCArrayOfStrings(input []string) **C.char {
+	arr := C.malloc(C.size_t(len(input)) * C.size_t(unsafe.Sizeof(uintptr(0))))
+
+	pointers := unsafe.Slice((**C.char)(arr), len(input))
+
+	for i, s := range input {
+		pointers[i] = C.CString(s)
+	}
+
+	return (**C.char)(arr)
+}
+
+func freeCArrayOfStrings(input **C.char, length C.size_t) {
+	if length == 0 {
+		return
+	}
+
+	pointers := unsafe.Slice(input, length)
+
+	for i := range length {
+		C.free(unsafe.Pointer(pointers[i]))
+	}
+
+	C.free(unsafe.Pointer(input))
+}

go/symbolizer_test.go

@@ -2,6 +2,7 @@ package blazesym_test
 
 import (
 	"debug/elf"
+	"io"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -97,16 +98,20 @@ func testElfDwarfSource(t *testing.T, source *blazesym.ElfSource, hasCodeInfo bo
 	}
 
 	if hasCodeInfo {
-		if syms[0].CodeInfo.Dir == "" {
-			t.Errorf("expected non-empty dir, got %q", syms[0].CodeInfo.Dir)
-		}
+		if syms[0].CodeInfo == nil {
+			t.Error("expected code info to be present")
+		} else {
+			if syms[0].CodeInfo.Dir == "" {
+				t.Errorf("expected non-empty dir, got %q", syms[0].CodeInfo.Dir)
+			}
 
-		if syms[0].CodeInfo.File != "test-stable-addrs.c" {
-			t.Errorf("expected file to be test-stable-addrs.c, got %q", syms[0].CodeInfo.File)
-		}
+			if syms[0].CodeInfo.File != "test-stable-addrs.c" {
+				t.Errorf("expected file to be test-stable-addrs.c, got %q", syms[0].CodeInfo.File)
+			}
 
-		if syms[0].CodeInfo.Line != 10 {
-			t.Errorf("expected line to be 10, got %d", syms[0].CodeInfo.Line)
+			if syms[0].CodeInfo.Line != 10 {
+				t.Errorf("expected line to be 10, got %d", syms[0].CodeInfo.Line)
+			}
 		}
 	} else {
 		if syms[0].CodeInfo != nil {
@@ -146,16 +151,20 @@ func testElfDwarfSource(t *testing.T, source *blazesym.ElfSource, hasCodeInfo bo
 		}
 
 		if hasCodeInfo {
-			if syms[i].CodeInfo.Dir == "" {
-				t.Errorf("expected non-empty dir, got %q", syms[i].CodeInfo.Dir)
-			}
-
-			if syms[i].CodeInfo.File != "test-stable-addrs.c" {
-				t.Errorf("expected file to be test-stable-addrs.c, got %q", syms[i].CodeInfo.File)
-			}
-
-			if syms[i].CodeInfo.Line == 0 {
-				t.Error("expected line to non-zero")
+			if syms[i].CodeInfo == nil {
+				t.Error("expected code info to be present")
+			} else {
+				if syms[i].CodeInfo.Dir == "" {
+					t.Errorf("expected non-empty dir, got %q", syms[i].CodeInfo.Dir)
+				}
+
+				if syms[i].CodeInfo.File != "test-stable-addrs.c" {
+					t.Errorf("expected file to be test-stable-addrs.c, got %q", syms[i].CodeInfo.File)
+				}
+
+				if syms[i].CodeInfo.Line == 0 {
+					t.Error("expected line to non-zero")
+				}
 			}
 		} else {
 			if syms[i].CodeInfo != nil {
@@ -186,3 +195,93 @@ func TestSymbolizeElfDwarf(t *testing.T) {
 		})
 	}
 }
+
+func copy(dst, src string) error {
+	s, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+
+	defer s.Close()
+
+	d, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+
+	defer d.Close()
+
+	_, err = io.Copy(d, s)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func TestConfigurableDebugDirs(t *testing.T) {
+	tmp, err := os.MkdirTemp(os.TempDir(), "*")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	dst := filepath.Join(tmp, "test-stable-addrs-stripped-with-link.bin")
+
+	err = copy(dst, filepath.Join("../data", "test-stable-addrs-stripped-with-link.bin"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	symbolizer, err := blazesym.NewSymbolizer(blazesym.WithDebugDirs([]string{}))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	syms, err := symbolizer.SymbolizeElfVirtOffsets(&blazesym.ElfSource{Path: dst, DebugSyms: true}, []uint64{0x2000200})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if syms[0].Name != "" {
+		t.Errorf("expected symbol to be not resolved, got %q", syms[0].Name)
+	}
+
+	if syms[0].Reason != blazesym.SymbolizeReasonMissingSyms {
+		t.Errorf("expected reason to be SymbolizeReasonMissingSyms, got %v", syms[0].Reason)
+	}
+
+	debugDir1, err := os.MkdirTemp(os.TempDir(), "*")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	debugDir2, err := os.MkdirTemp(os.TempDir(), "*")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	debugDst := filepath.Join(debugDir2, "test-stable-addrs-dwarf-only.dbg")
+
+	err = copy(debugDst, filepath.Join("../data", "test-stable-addrs-dwarf-only.dbg"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	symbolizer, err = blazesym.NewSymbolizer(blazesym.WithDebugDirs([]string{debugDir1, debugDir2}))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	syms, err = symbolizer.SymbolizeElfVirtOffsets(&blazesym.ElfSource{Path: dst, DebugSyms: true}, []uint64{0x2000200})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if syms[0].Name != "factorial" {
+		t.Errorf("expected symbol to resolve to factorial, got %q", syms[0].Name)
+	}
+
+	if syms[0].Module != dst {
+		t.Errorf("expected module to be %q, got %q", dst, syms[0].Module)
+	}
+}