* fix(ghidra): mark empty xrefs results as unresolved, not unreferenced
Ghidra 12.2 resolves no references to data addresses on some Mach-O
imports, and xrefs returned a bare empty list with nothing separating
'no references exist' from 'this provider resolved no references', so
callers concluded addresses were unreferenced.
projectExecution now attaches ghidraEmptyXrefsLimitation to an empty
xrefs result: the list reflects what this analysis resolved, not proof
the address is unreferenced. Non-empty results carry no caveat.
Covered by behavior tests for both branches; validated against
FM9-Edit-arm64 (expect: limitation) once the daemon session reopens.
* fix(ghidra): drop circular trace_feature cross-check from empty xrefs caveat
trace_feature calls xrefs internally, so recommending it as an independent
cross-check repeats the same lookup the caveat qualifies. Keep disassembly
as the single independent check.
* fix(ghidra): report actionable-reference absence and invalidate stale snapshots
Review follow-up on the empty xrefs caveat:
- The bridge filters synthetic entry-point references before observation, so
"resolved no references" could be false; the caveat now reports that no
actionable references were returned and names the omission.
- Drop the trace_feature cross-check: traceReferences observes xrefs per
matched string, repeating the same lookup instead of independent evidence.
- Bump instruction_references semantics to v3 so analysis snapshots captured
before the caveat replay no bare empty results; the profile commitment in
the snapshot binding no longer matches.
* feat(ghidra): mark empty function-reference facets as unresolved too
Extends the empty-xrefs caveat to the sibling ReferenceManager consumers
review follow-up identified: procedure_references and analyze_function
reference facets built on the same observation path could still present
empty arrays as collected facts.
- ghidraEmptyFunctionReferencesLimitation attaches when
procedure_references returns no references for the requested direction
and when a dossier observes no references in either direction;
callers/callees (function-manager derived, observed working on the
reported target) stay caveat-free.
- One emptyReferenceCaveat owner replaces the inline xrefs branch.
- function_references semantics bump to v3 so snapshots captured before
the caveat do not replay bare empty facets; raw profile digests
recomputed.
* fix(ghidra): cover annotation and instruction reference facets in the caveat
Review follow-up: annotate_native_function returns a dossier built by the
same analyzeFunction collection and inspect_native_instruction builds
incoming_references with visitObservedReferencesTo; both could present
empty arrays as collected facts under the reported ReferenceManager
failure.
- annotate_native_function attaches the caveat when its dossier observes
no references in either direction.
- inspect_native_instruction attaches it when incoming_references is an
explicit empty array (null or omission stays unavailable, matching the
field contract).
- Split the diagnostics describe to keep each block under the lint bound.
- Behavior tests cover attach and non-attach for both operations.
* fix(ghidra): name the honest cross-check limits in the reference caveats
Review follow-up: the motivating failure was a string address, so
'cross-check the disassembly at this address' pointed at nothing — data
and string addresses have no instruction to disassemble — and
inspect_native_instruction's incoming_references is built through the
same visitObservedReferencesTo path, so it was not independent either.
- xrefs caveat now states that no independent in-product cross-check
exists for the empty result, that surrounding disassembly only helps
at a code address, and that data or string addresses need an external
disassembly scan (otool -tV adrp/add pairing).
- Function-facet caveat separates outgoing references (own disassembly
is independent) from incoming references (no in-product check; scan
other code externally).
* fix(ghidra): use the address-scoped caveat for inspect_native_instruction
Greptile review follow-up: inspect_native_instruction checks incoming
references to one exact address, so the function-scoped caveat misdescribed
the scope; an instruction can be unreferenced while its function has
references elsewhere, and the address may have no containing function.
Attach the address-scoped xrefs caveat instead.
* fix(ghidra): qualify each empty reference direction independently
Analyze-function and annotate-native-function results attached the
unresolved-references caveat only when BOTH reference directions were
empty, so a dossier with one populated direction presented its empty
direction as a collected fact.
Split the combined function-references caveat into direction-scoped
limitations and attach one per empty direction (analyze_function,
annotate_native_function dossier readback, procedure_references by its
requested direction).
* fix(ghidra): qualify empty outgoing instruction references
inspect_native_instruction results carry two independent
ReferenceManager facets: the incoming list and the outgoing references
built from instruction.getReferencesFrom(). Only the incoming list was
checked, so an instruction with a populated incoming list and no
outgoing references presented the empty outgoing facet as a collected
fact, and any populated incoming list suppressed the caveat entirely.
Each facet is now qualified independently: the empty incoming list
keeps the address-scoped caveat; the empty outgoing list attaches the
new instruction-scoped outgoing limitation (this stream is not
entry-point filtered, so it claims no entry-point omission). Truth
table covered in describe("Ghidra empty instruction reference facets").
* fix(ghidra): gate the instruction outgoing caveat on decoded status
Non-decoded inspect_native_instruction results (data, not-in-listing,
not-instruction-boundary, outside-memory) return before the bridge ever
queries instruction.getReferencesFrom(), so their empty references list
is an unobserved facet, not an empty ReferenceManager observation. The
unconditional outgoing caveat claimed the ReferenceManager returned no
references from an instruction that does not exist at that address.
The outgoing limitation now attaches only when status is decoded; the
address-scoped incoming caveat still applies per the empty incoming
list, matching the original motivating data-address case.
* fix(ghidra): dossier incoming omission and external outgoing recovery
Two unqualified cases remained in the function-reference caveats:
- The analyze_function/annotation dossier excludes incoming references
whose source is inside the function's own body (a self-recursive call
is enough), so the projected empty list can mean 'no outside source
observed' or 'only in-body sources observed'. The dossier now uses a
dedicated incoming limitation naming the exclusion, pointing at the
outgoing edges/disassembly where in-body edges remain visible, and at
procedure_references(incoming) - the same ReferenceManager stream
without the in-body exclusion - as the in-product discriminator.
procedure_references keeps the generic incoming caveat: its incoming
stream is not in-body filtered.
- An external function has no local body, so the outgoing caveat's
'function's own disassembly' recommendation was impossible. Records
classified external now get an external-specific outgoing limitation
naming the defining artifact and this program's call sites instead
(procedure_references outgoing, analyze_function, annotation readback).
* fix(ghidra): qualify dossier incoming caveat observation
The dossier-specific incoming caveat claimed the ReferenceManager
observed no incoming references from outside the body, but
visitObservedReference (ReaGhidraBridge.java:3973-3974) drops
entry-point references before the body filter (1619-1621), so the
manager may have returned references the dossier never reports.
Reframe as 'returned no actionable' and name both omissions; correct
the recovery claim: procedure_references(incoming) lacks the in-body
filter but omits synthetic entry-point references as well.