Skip to content

Fix stack object finalizer liveness#1906

Open
cpunion wants to merge 53 commits into
xgo-dev:mainfrom
cpunion:codex/goroot-stackobj-coverage
Open

Fix stack object finalizer liveness#1906
cpunion wants to merge 53 commits into
xgo-dev:mainfrom
cpunion:codex/goroot-stackobj-coverage

Conversation

@cpunion

@cpunion cpunion commented May 22, 2026

Copy link
Copy Markdown
Collaborator

Summary

  • implement runtime.SetFinalizer on top of BDWGC finalizers and run queued Go finalizers during runtime.GC
  • add scoped conservative stack/register cleanup for command-line LLGo programs to address stack object/finalizer liveness cases
  • add stable test/go coverage for finalizer behavior and stack-object liveness, and un-xfail the verified darwin/arm64 goroot cases

Tests

  • go install ./...
  • go test ./test/go -run 'TestRuntimeSetFinalizer' -count=1 -v
  • LLGO_ROOT=/Users/lijie/source/goplus/llgo-wt-goroot-stackobj llgo test -run 'TestRuntimeSetFinalizer' -timeout=20m -count=1 ./test/go
  • go test -v ./test/goroot -run '^TestGoRootRunCases$' -goroot $(go env GOROOT) -case '^(deferfin|tinyfin|stackobj|stackobj3)\.go$' -xfail /tmp/llgo-empty-xfail.yaml -count=1 -build-timeout 5m -run-timeout 20s -progress 20s
  • go test ./cl ./ssa ./test/goroot -run 'Test(ParseDirective|XFail)' -count=1
  • go test ./cl ./ssa -count=1
  • git diff --check

Notes

  • The conservative liveness cleanup is intentionally limited to command-line-arguments; the test/go subprocess probe keeps coverage stable even without the full goroot workflow.
  • Linux goroot xfails for these cases are left in place because this pass was verified locally on darwin/arm64 only.

@cpunion

cpunion commented May 22, 2026

Copy link
Copy Markdown
Collaborator Author

Updated with Linux pthread feature macro fix in runtime/internal/lib/runtime/_wrap/runtime.c so pthread_getattr_np is declared on glibc-based CI.

Local verification:

  • go test ./test/go -run 'TestRuntimeSetFinalizer' -count=1 -v
  • go run -tags=dev ./cmd/llgo test -run 'TestRuntimeSetFinalizer' -timeout=20m -count=1 ./test/go
  • go test ./cl ./ssa -count=1
  • git diff --check

@cpunion

cpunion commented May 22, 2026

Copy link
Copy Markdown
Collaborator Author

Updated again after LLGo shard 2 exposed a link failure from compiler-injected stack liveness helpers.

Fixes in 36044708d:

  • emit calls to the C runtime wrapper symbols directly instead of skipped Go helper wrappers
  • only enable conservative stack liveness clearing for command-line-arguments packages that actually call runtime.SetFinalizer, avoiding unrelated test/go programs pulling in the helper symbol

Local verification:

  • LLGO_BUILD_CACHE=off go test ./test/go -run 'TestRuntimeSetFinalizerStackObjectLiveness|TestStringConversionFromWideIntegers' -count=1 -v
  • go test ./cl ./ssa -count=1
  • git diff --check

Note: LLGO_BUILD_CACHE=off go run -tags=dev ./cmd/llgo test ... reached program execution locally but hit a macOS temp-dir cleanup error (operation not permitted) after the target code path; the plain Go test wrapper passed the same LLGo programs.

@codecov-commenter

codecov-commenter commented May 22, 2026

Copy link
Copy Markdown

@cpunion cpunion mentioned this pull request May 24, 2026
@cpunion cpunion force-pushed the codex/goroot-stackobj-coverage branch from 3604470 to 23c7b8e Compare June 10, 2026 11:30
@cpunion cpunion force-pushed the codex/goroot-stackobj-coverage branch from 6c251ce to 179c4dc Compare June 27, 2026 13:17
@cpunion cpunion marked this pull request as ready for review June 28, 2026 06:09
@cpunion cpunion force-pushed the codex/goroot-stackobj-coverage branch from d70d4b5 to 5e2b697 Compare June 29, 2026 02:26
cpunion and others added 27 commits July 2, 2026 15:33
Every Caller/Callers capture used to intern the frame into the
synthetic table: a hash probe plus a full frame comparison per stack
slot per call. Memoize the interned PC base in the shadow-stack slot
and invalidate it when the recorded line changes (for one entry the
instrumented name/file operands are constants, so the line is the only
thing that varies between call sites). The three static frames emitted
around every Callers walk get per-store memo slots, and the emit loop
is unrolled so nothing escapes and skipped frames are never captured.

macOS: hot.CallersOnly 182ns -> 125ns (Go 1.26: 118ns); with LTO 96ns.
hot.CallersFramesFirst 528ns -> 471ns, 354ns with LTO (Go: 401ns).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…py limit

Frames.Next allocated a fresh *Func per symbolized frame; route it
through the FuncForPC 4-way cache so repeated CallersFrames walks over
the same PCs stop allocating. hot.CallersFramesFirst: macOS 471->456ns
(338ns with LTO, Go 1.26: 406ns); Linux LTO reaches parity at 433ns.

Also document a pre-existing limitation at the entry-site emitter: the
body-embedded inline-asm record is duplicated by LTO inlining into
every inline site (~4x section growth on multipkg) and registers
host-function PCs under the inlinee's symbol ID. Runtime only consults
the table when native symbolization fails, which bounds the impact;
the fix (data globals with !associated metadata) needs
LLVMGlobalSetMetadata in the llvm binding and lands with the
link-phase ftab work.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Record the experiment results at the emitter: !associated only guides
linker GC and IR-level GlobalDCE deletes the records; llvm.compiler.used
pins dead functions through the records' address initializers; and
noduplicate blocks inlining. Section dedup is link-phase work.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Post-link table generation plan: parse the linked binary's metadata
sections, dedup LTO inline copies against the symbol table, sort with a
sentinel, build Go-layout findfunctab via internal/pclntab, and write
back into a reserved section with ASLR-safe anchor offsets. Runtime
adopts the prebuilt table when the header validates and keeps first-use
construction as fallback. Includes the list of platform facts
established in xgo-dev#2012 so implementation does not re-derive them.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The monotonic time source had two problems:

- On Linux, runtimeNano passed clite's CLOCK_MONOTONIC, whose value is
  Darwin's clock id (6). Linux interprets 6 as CLOCK_MONOTONIC_COARSE,
  a millisecond-granularity clock: consecutive time.Now() readings were
  identical 100% of the time and the smallest nonzero delta was 1ms.
- On Darwin, clock_gettime(CLOCK_MONOTONIC) itself only has microsecond
  granularity (96% identical consecutive readings, 1us minimum delta).

Mirror Go's runtime structure with a per-OS nanotime1 in the runtime
package itself, keeping the hot path free of clite indirection and clite
unchanged: Darwin reads CLOCK_UPTIME_RAW through clock_gettime_nsec_np
(the same clock Go's nanotime uses there), Linux uses clock_gettime with
the OS-correct CLOCK_MONOTONIC id as a local constant, and remaining
platforms keep the previous behavior.

Measured with consecutive time.Now() deltas (min nonzero / zero-frac):
- macOS arm64: 1us / 96.5%  ->  41ns / 26%  (Go 1.26: 41ns / 22%)
- Linux arm64: 1ms / 100%   ->  41ns / 21%

time.Sleep, Timer and Ticker behave identically before and after.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The macOS CI LLDB step caught the funcinfo entry/stub site anchors
shifting instruction/scope layout: with the records emitted at function
entry, LLDB reported variables from an inner lexical block (ScopeIf's
b, c) as in scope before the block began. Debug builds carry full
DWARF, so the funcinfo tables are redundant there; gate the metadata
pipeline on !IsDbgEnabled(). Caller-frame instrumentation is
independent of this switch, so runtime.Caller keeps working in debug
builds. _lldb/runtest.sh: 194/194 pass.

This also covers Linux, where the same interference existed since the
sites were introduced but the LLDB suite only runs on the macOS jobs.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Refine the previous commit: instead of disabling the whole funcinfo
metadata pipeline under LLGO_DEBUG/LLGO_DEBUG_SYMBOLS, add a separate
Program.EnableFuncInfoSites switch and turn off just the body-embedded
site records (entry/stub anchors and pc-line labels) — they are what
shifts instruction/scope layout and confused LLDB. The funcinfo tables
are plain data globals and stay enabled, so runtime.FuncForPC keeps its
normalized name and Func.FileLine keeps file/line in debug builds (via
the dlsym fallback path); runtime.Caller/Callers were never affected
because caller-frame instrumentation is independent of both switches.

Debug builds lose only the section fast paths (first-use latency) and
statement-level pc-line granularity, both redundant next to full DWARF.
_lldb/runtest.sh: 194/194; cl and test/go suites pass.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
frameFuncForPC could cache a Func built from a pcline frame whose entry
resolution failed (entry == 0); a later FuncForPC on the same PC would
then observe Entry() == 0 where its own constructor falls back to pc.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
LLGO_FUNCINFO_SITES=0 keeps the funcinfo metadata tables but drops the
body-embedded entry/stub/pc-line inline-asm sites. This is the narrow
A/B needed to isolate codegen perturbation caused by the in-body asm
anchors: with sites off, plain-code benchmarks match the no-funcinfo
baseline within noise, while sites on shifts hot runtime-internal
loops by -30%..+6% through inline/layout decisions.

Semantics with sites off: FuncForPC(entry) and Func.FileLine(entry)
keep working through the dlsym fallback path; statement/call-site
granularity PC line lookup is disabled, and first-use table
construction loses the section fast path.

Tests assert the split: tables still materialize while entry/stub
section asm, boundary symbols, and pc-line site labels are all absent.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
First stage of doc/design/pclntab-linkphase.md: parse a linked binary's
funcinfo entry/stub sections (Mach-O and ELF), deduplicate LTO inline
copies against the symbol table's text ranges, sort with a Go-style
sentinel, and build findfunctab through internal/pclntab — the faithful
port that has been waiting for exactly this caller. Read-only: prints
what the P2 build integration would write back.

Measured on the 576-target multipkg binaries:
- non-LTO: 9319 records -> ftab 3161 + 207 buckets; lookup self-check
  3160/3160; site sections 149KB -> 29KB (5.1x)
- LTO: 15371 entry records -> 13857 inline copies dropped, 4144 kept;
  self-check 3045/3045; 299KB -> 28.5KB (10.5x)

Findings for P2: on-disk Mach-O pointer slots hold dyld chained-fixup
encodings (low 36 bits are the target; decoded here; the write-back
design stores anchor-relative offsets and avoids pointers entirely),
and some non-LTO stub symbols are absent from the symbol table
(records conservatively dropped; needs tightening).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…adoption

pclnpost -write rewrites the entry-site section in place with the
prebuilt table (header + ftab {entryOff,funcIndex} + runtime-layout
findfunctab buckets), resolving funcinfo indexes through the binary's
symbol-index section, and voids the stub section (its records are
merged into the table). ASLR is handled by anchoring on the section's
own link-time address; entries are normalized to true symbol starts,
which retires the entry-PC slack on this path. macOS re-signs with an
ad-hoc codesign after rewriting.

The runtime adopts the table zero-copy when the magic header validates:
lookups binary-search the on-disk ftab directly through the shared
bucket index, nothing is materialized on first use (the funcIndex ->
entry map is built lazily and only for the pcline initializer), and the
cold scan/dladdr path is skipped since adoption is cheap. First-use
construction remains the fallback whenever the header is absent.

Linux end-to-end: entries=prebuilt, FuncForPC/FileLine correct,
first-FuncForPC 110µs (materializing) -> 6-8µs (zero-copy); 13ms on the
original macOS baseline. Known gap: on macOS the on-disk rewrite is
corrupted at load time because dyld still walks the stale chained-fixup
chain over the section; fix (unlinking the section's nodes from the
page chains in LC_DYLD_CHAINED_FIXUPS) is identified and next.
Non-prebuilt paths verified regression-free: cl + test/go suites pass,
smoke behavior unchanged.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Every llgo-linked executable (linux/darwin, sites enabled) now gets the
prebuilt ftab/findfunctab automatically: internal/build runs
internal/pclnpost.Rewrite after linkMainPkg, and any failure degrades
silently to the first-use construction fallback.

Moves the tool core into internal/pclnpost and hardens it:

- Canonical-record detection by FNV: a record survives when its anchor's
  owning symbol hashes to the record's symbolID (or is the __llgo_stub.
  wrapper of it). The previous one-per-symbolID rule wrongly collapsed a
  function with its stub — they share the target's symbolID by design —
  which broke exact-entry lookups (caught by TestRuntimeLineInfoAndStack
  on Linux). LTO inline copies are now identified exactly: 8.4k/9.5k
  copies removed in the LTO probes.
- Mach-O chained-fixups surgery: unlink the rewritten sections' pointer
  slots from the dyld page chains (repointing predecessors' next links
  and page_start entries) so dyld neither rebases slots inside the new
  table nor skips unrelated fixups after the zeroed stub section, then
  re-sign ad hoc. Without this the table was corrupted at load.
- LTO-safe metadata location: the entry section carries a meta record
  whose relocations hold the addresses of the symbol-index pointer and
  count globals; LTO internalization strips those names from the symbol
  table but relocations always resolve. Runtime skips the meta rows
  (pc==0 / symbolID==0).
- Idempotence guard (already-rewritten binaries are left alone).

Runtime fixes that surfaced during validation:

- materializePrebuiltEntries is now two-phase so concurrent losers wait
  for the winner's store instead of reading a nil entries slice.
- pcLineFrameForPC rejects nearest-below sites whose entry is
  unresolved when the caller knows the function entry, instead of
  leaking a neighboring function's file/line.

Validation: macOS cl (full) + test/go + LLDB 194/194; Linux test/go
TestRuntime suite; probes on both platforms report entries=prebuilt
with first-FuncForPC at 7-21µs (Linux) from 13ms on the original
baseline, and LTO builds drop 8-9.5k inline copies.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…table

On Mach-O, pointer slots that name exported functions — every
__llgo_stub.* wrapper and any exported Go function — are emitted as
chained-fixup BIND nodes, not rebases. The rewriter only decoded rebase
nodes, so all stub records (and some entry records) were dropped as
unowned and never reached the prebuilt ftab; FuncForPC on function
values silently fell back to dladdr (~6µs per fresh pc on darwin).

- Parse the LC_DYLD_CHAINED_FIXUPS imports table and resolve bind
  ordinals to their in-image definitions.
- Match canonical owners against the record symbolID with underscore
  normalization (debug/macho's suffix-shared string table can surface
  one mangling underscore more or less than the source-level name).
- Splice the prebuilt header's base slot back into the fixup chain as a
  live rebase node: dyld writes the slid text base at load, so the
  runtime reads a ready runtime PC with no slide arithmetic (non-PIE
  ELF link-time values already equal runtime addresses).
- LLGO_PCLNPOST=0 escape hatch keeps first-use construction.

Fresh-pc FuncForPC slow path: darwin 6-8µs -> 1.2-1.7µs, linux
6.8µs -> 0.5µs; first-in-process lookup: darwin ~32µs -> ~14µs,
linux ~6.8µs -> ~4µs.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Pure-compute probes (recursive fib, JSON round-trip, sort.Ints, map
churn) with no runtime introspection, so one harness run covers both
the introspection extremes and what the funcinfo machinery costs code
that never asks for it.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Go's pclntab pages are touched by its own runtime (traceback, GC) long
before user code queries it, so its first FuncForPC never pays page-in.
Mirror that: when the prebuilt table is present, init adopts it
(zero-copy, sub-µs), touches the pages the lookup path reads (blob,
funcinfo records, string offsets, strings), runs one synthetic lookup
to warm the code paths, and write-warms the FuncForPC cache pages.

First-in-process FuncForPC: darwin ~17µs -> ~2.8µs, linux ~6.6µs ->
~1.0µs. Startup cost is page-count-bound (tens of µs on stdlib-sized
tables, invisible next to ~3ms process startup; hello-world medians
unchanged). Non-prebuilt binaries stay fully lazy: first-use
construction allocates, which has no place in init, and programs that
never introspect pay nothing.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
-depths generates deep_<N> scenarios at configurable call depths;
-bigsizes generates bigfunc scenarios (funcs x statements) whose large
bodies stress statement-level pcline density, mid-function pc
symbolization, and ordinary performance of big method bodies.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
@cpunion cpunion force-pushed the codex/goroot-stackobj-coverage branch from 5e2b697 to 2ea90eb Compare July 2, 2026 15:03
@cpunion

cpunion commented Jul 2, 2026

Copy link
Copy Markdown
Collaborator Author

Rebased onto #2016 (codex/pclntab-linkphase-p1, which includes #2012) per the review-order plan: #2012#2016 → this line of semantics fixes. Conflicts resolved were additive (context fields, the noinline condition set, and runtime.Panic now calls SavePanicCallerFrames() before the panic-node bookkeeping). Note the PR base is still main, so the diff shows #2012/#2016 commits until those merge.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants