trace-callers

Trace reverse call chains to reveal direct and indirect callers of a target function.

15|4|Updated Mar 7, 2026
One-click install
npx skills add https://github.com/vzco/arc-probe --skill trace-callers
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: trace-callers
Source: https://github.com/vzco/arc-probe/tree/main/plugins/arc-probe/skills/trace-callers
Command: npx skills add https://github.com/vzco/arc-probe --skill trace-callers

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Discover how a target function is reached by tracing direct and indirect callers, building a reverse call tree to illuminate execution context and entry points.

Core Features & Use Cases

  • Direct caller discovery: identify callers at multiple levels to construct a comprehensive call graph.
  • Disassembly context: capture nearby instructions to infer argument setup and calling conventions.
  • Cycle detection & pruning: prevent infinite traversal and highlight widely called utilities.
  • Tree-driven navigation: output a structured tree suitable for GUI labeling and analysis.

Quick Start

Run the trace for a target function address to generate the reverse call tree.

Frequently Asked Questions about trace-callers

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I trace reverse call chains to find the root callers of a target function?

Trace reverse call chains by enumerating direct and indirect callers of a target function address. This builds a reverse call tree, illuminating execution context and revealing entry points up to a configurable depth.

Can I capture disassembly context to infer argument setup during a reverse call tree trace?

Yes, disassembly context is captured during the reverse call tree trace. This captures nearby instructions to help you infer argument setup and understand calling conventions for each caller.

How does cycle detection work when tracing indirect callers in a reverse call graph?

Cycle detection prevents infinite traversal by pruning repeated paths when tracing indirect callers. This avoids infinite loops and highlights widely called utility functions within the reverse call tree.

Does this reverse call tree tracing support dynamic analysis of binary code in Windows x64 environments?

Yes, reverse call tree tracing is applicable to dynamic analysis of binary code specifically in Windows x64 environments. It resolves addresses automatically and captures disassembly context for x64 binaries.

What is the best way to navigate a structured reverse call tree output for binary analysis?

The best way to navigate a reverse call tree is through its structured output format. This tree-driven output is suitable for GUI labeling and analysis, allowing you to visualize function invocation paths clearly.

Why does tracing direct and indirect callers stop at a certain depth instead of finding all root entry points?

Tracing stops at a configurable depth to manage analysis scope and prevent infinite traversal. Cycle detection and pruning further limit the trace, highlighting widely called utilities while avoiding endless loops.