symbolize: name the module when the symbol is unknown

[dpsoft]

An unresolved frame now reads libcuda.so.550.54.14+0x14b71c6 instead of 0x7f2c945b2c2b.

The RTX 3090 profile's 16-frame joined stack has seven consecutive bare-hex frames — libcuda/libcupti internals. NVIDIA ships no debug symbols for those, so the function name is genuinely unrecoverable. The module is not, and knowing a frame is seven deep inside libcuda is most of the diagnostic value.

Where the module was lost — not where I guessed

I assumed it was dropped downstream. It is not.

blazesym does not populate Frame.Module on a miss. symbolizer.rs returns Symbolized::Unknown(reason) — a variant carrying a reason and nothing else — while handle_entry_addr had the MapsEntry, path and all, one frame earlier. The C API then zeroes every other field (capi/src/symbolize.rs:1105). The module never arrived; nothing downstream lost it.

A second, independent loss: cmd/gpu-cuda-profile builds with no Resolver, so addLocation's only route to a real mapping never runs. The raw dump shows this beyond the single-mapping line — every location reads 0x0 M=1, resolved ones included.

And wiring a Resolver into that builder cannot fix it: the GPU tools build the profile after cmd.Wait(), when /proc/<pid>/maps is gone. The lookup must happen at symbolization time, which settles the layering.

Rendering

Function.Name carries the module+offset, Location.Address the same module-relative file offset, plus a real Mapping (path/start/limit/build-id). Function.Name because go tool pprof reads this file too and knows none of perf-agent's conventions — one mechanism, both audiences.

Module-relative, not absolute: 0x7f2c945b2c2b is meaningless across runs under ASLR; libcuda.so.1+0x14b71c6 is stable and can be fed to addr2line later.

Two honesty features that needed defending against this improvement

1. flamegraph.Classify checked module rules before isUnsymbolized. That ordering was only safe while GPU profiles had no modules. With them, an unnamed libcuda frame matches isVendorModule and gets painted as ordinary vendor code — making DomainUnsymbolized ("vendor, no symbols", the hatched one) unreachable for vendor libraries. isUnsymbolized moved above the module rules; [kernel] stays above it.
2. foldedstacks.isAddressOnly now recognizes the new form, so AddressOnlyFrames and the "N of M frame slots have no symbol" banner read identically before and after. A test asserts that equality directly — otherwise the honest 15.5% gap would have silently become 0% while nothing improved.

The no-mapping case

Stays bare hex, behind four guards: a Lookup hit is required; frameMapping refuses a range not containing its own address; framename.Format refuses [kernel]/[jit]; and it is counted apart via LocalStats.ModulesAttached/ModulesBare and gpuprobe.Stats.StackFramesModuleOnly. One residual ambiguity is documented and pinned by TestKnownAmbiguity rather than hidden.

CPU profilers

Additive. The builder's Resolver branch still runs first and wins, so resolved frames and existing mapping attribution are byte-identical. Two deliberate changes: an unresolved frame no longer sets Mapping.HasFunctions (it is in the profile because symbols are missing), and hex-named frames with a vendor/system module move to the hatched unsymbolized domain. They also gain module names — the intended benefit, for free.

Cannot verify end to end

CapEff: 0, no GPU, and gpu-cuda-45.pb.gz cannot be re-rendered because the mapping data was never written into it. The e2e test transcribes the real 16-frame stack out of that file (raw locations 4..18 then 2): TestGPUStack_Before reproduces today's output, TestGPUStack_After shows all seven becoming libcuda.so.550.54.14+0x…. The mapping ranges are a labelled fixture; the stack, names, addresses and arithmetic are real.

A fresh 3090 run should show: >1 mapping in -raw, locations reading 0x<offset> M=<n>, the seven frames named, StackFramesModuleOnly close to StackFramesUnresolved (0 means the index is not reaching the symbolizer), and the gap warning still ~15%, not 0%.