The Coverage Gap in Dynamic Program Analysis

You are reading version 1 of this direction, frozen 2026-10-04. The latest version is version 2.

Version 1 of 251 papers54 conceptsfrozen 2026-10-04

Software analysis traditionally splits into two camps: static analysis, which examines code without running it, and dynamic analysis, which observes a program's behavior during execution. While static analysis can be "sound" (seeing all possible paths), it often struggles with the sheer complexity of modern software, leading to false positives.

Dynamic analysis offers a compelling alternative: by looking at execution traces, researchers can capture the "ground truth" of how a program actually behaves. However, this precision comes with a fundamental limitation known as the coverage gap. If a specific line of code or a malicious payload is never triggered during the observation period, the analysis remains entirely blind to it.

The Power of Behavioral Ground Truth

The core intuition behind dynamic analysis is that behavior is often a more accurate representation of a program's intent than syntax. For example, Ke Wang and Zhendong Su demonstrated that training neural networks on dynamic execution traces rather than source code allows for significantly more accurate program repair, achieving over 90% accuracy in identifying student errors Dynamic Neural Program Embeddings for Program Repair.

This behavioral approach is particularly useful when the source code is unavailable or intentionally obscured. In the realm of reverse engineering, Thomas Reps and Venkatesh Srinivasan developed Lego, which reconstructs complex C++ class hierarchies from stripped binaries by monitoring object lifetimes and method calls Recovery of Class Hierarchies and Composition Relationships from Machine Code. Similarly, Choong-Hwan Lee and Grigore Roşu used dynamic "slicing" of execution traces to discover hidden API protocols that govern how multiple objects interact Mining parametric specifications.

The Blind Spot: Why Coverage Fails

The Achilles' heel of these techniques is their dependency on the quality of the input workloads. As Madhur Gupta and Samuel P. Midkiff note, dynamic analysis can only observe code paths that are actually triggered; malicious logic residing in unexecuted branches remains undetected Extracting Source Level Program Similarities from Dynamic Behavior.

This "blind spot" creates several critical failure modes across different research areas:

  1. Security Policy Fragility: Tools like Cimplifier Vaibhav Rastogi and BEACON Haney Kang generate "least-privilege" security policies for containers by watching them run. However, if a rare error handler or a specific production feature isn't triggered during the profiling phase, the resulting policy might block a necessary system call, causing the application to crash in production BEACON : Automatic Container Policy Generation using Environment-aware Dynamic Analysis.
  2. Incomplete Specifications: When mining program invariants (rules that are always true), tools like Daikon are limited by the breadth of available traces. If the test cases are incomplete, the tools may generate "false" invariants that only hold true for those specific inputs rather than the entire program Can Large Language Models Reason about Program Invariants?.
  3. Evasive Malware: In Android security, Mu Zhang and Heng Yin found that dynamic unpacking is fundamentally limited because it can only recover code segments that execute during the observation period Things You May Not Know About Android (Un)Packers.

Bridging the Gap with Hybrid Feedback Loops

To overcome the coverage wall, recent research has moved toward hybrid systems that combine dynamic observation with active exploration.

One prominent strategy is the use of feedback loops. Lingming Zhang and Sarfraz Khurshid introduced iDiscovery, which uses symbolic execution to automatically generate new test cases that attempt to refute the invariants discovered by dynamic analysis Feedback-driven dynamic invariant discovery. This forces the system to explore the "edges" of the program logic.

Another approach involves fuzzing to broaden the diversity of execution traces. Jianyu Zhao and Steven Y. Guo developed Fuzz Tuning, which uses fuzzing to generate a wide variety of inputs. These inputs trigger diverse code paths, which are then fed into Large Language Models (LLMs) to help them better understand program behavior Understanding Programs by Exploiting (Fuzzing) Test Cases.

By treating dynamic traces not as a complete map, but as a high-fidelity starting point that must be expanded through automated testing, these researchers are turning the "blind spot" of dynamic analysis into a navigable frontier.

Papers in this version

History & citationVersion 2 · 2026-10-04

Current · Permanent link

  1. Version 2 (latest) · 2026-10-04 · 112 papers
  2. Version 1 · 2026-10-04 · 51 papers
Cite this direction

Latest version (a living page):

@misc{lacuna_dynamic_analysis_coverage_gap_0074040b,
  title = {dynamic analysis coverage gap},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/dynamic-analysis-coverage-gap/rdr_0074040b4f784ecc9059906827c2f929},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_the_coverage_gap_in_dynamic_program_anal_0074040b_v1,
  title = {The Coverage Gap in Dynamic Program Analysis},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/the-coverage-gap-in-dynamic-program-analysis/rdr_0074040b4f784ecc9059906827c2f929/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}