dynamic-instrumentation

Instrument binary execution to capture dynamic instruction, memory, and control-flow events.

69|11|Updated May 16, 2026
One-click install
npx skills add https://github.com/NeverSight/NeverC --skill dynamic-instrumentation-neversight
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dynamic-instrumentation
Source: https://github.com/NeverSight/NeverC/tree/main/.agents/skills/dynamic-instrumentation
Command: npx skills add https://github.com/NeverSight/NeverC --skill dynamic-instrumentation-neversight

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Dynamic instrumentation helps you understand what a program is really doing at runtime—such as where execution goes, what memory it touches, and how control flow changes—especially when source code is missing, incomplete, or you need behavior verified in production-like conditions.

Core Features & Use Cases

  • Dynamic Binary Instrumentation (DBI): Inject analysis callbacks to monitor instructions, memory reads/writes, and control-flow events while the program runs.
  • LLVM-based runtime instrumentation: Use LLVM instrumentation passes and frameworks to add tracing/profiling at IR level, including sanitizer coverage-style collection.
  • Runtime tracing & monitoring use cases: Apply function tracing, XRay-style patch/unpatch instrumentation, profiling (e.g., block frequency), syscall monitoring patterns, and eBPF coverage collection concepts.

Use cases include security research (behavior validation and monitoring), debugging opaque binaries, building coverage feedback for fuzzers, and implementing runtime performance/security monitors.

Quick Start

Use the dynamic-instrumentation skill to design an LLVM/DBI-based tracing pipeline by choosing an instrumentation approach (e.g., QBDI callbacks or LLVM IR passes) and specifying which events to record (instructions, memory access, syscalls, or coverage) for your target program.

Frequently Asked Questions about dynamic-instrumentation

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

FAQPage Schema
How does dynamic binary instrumentation work for tracing runtime program behavior?

Dynamic binary instrumentation injects analysis callbacks into binary execution to capture dynamic instruction, memory, and control-flow events while the program runs. It helps understand runtime behavior when source code is missing or incomplete.

How do I collect coverage feedback for fuzzing using LLVM instrumentation?

You can collect coverage feedback for fuzzers by applying LLVM-based runtime instrumentation and sanitizer coverage-style collection at the IR level. This captures execution paths to guide fuzzing inputs toward uncovered code regions.

Can I monitor syscalls and memory access in production-like conditions without source code?

Yes, dynamic instrumentation enables runtime tracing and syscall monitoring by injecting callbacks directly into binary execution. This allows you to verify behavior and monitor memory reads or writes in production-like conditions without source code.

What is the best way to instrument opaque binaries for security research and debugging?

The best way to instrument opaque binaries is using a DBI framework or LLVM IR passes to inject deterministic callbacks. This captures control-flow events and validates runtime behavior for security research and debugging tasks.

Does this dynamic instrumentation approach support XRay-style tracing and eBPF coverage collection?

Yes, the instrumentation strategy supports XRay-style patch and unpatch tracing, block frequency profiling, and eBPF coverage collection concepts. It applies across platforms for runtime performance and security monitoring.

What are the limitations of using LLVM IR passes for runtime tracing?

LLVM IR passes require an LLVM-aligned instrumentation strategy and access to target binaries for IR-level insertion. While effective for tracing and profiling, they may introduce overhead that requires event filtering and low-overhead logging patterns to manage.