Non-Termination Proving: 100 Million LoC and Beyond

2025-09-05

AI Summary

Automatically verifying non-termination in large-scale programs (exceeding 100 million lines of code) remains a fundamental challenge due to scalability limitations of existing static analysis tools. Method: This paper introduces the first scalable, compositional under-approximation framework for proving non-termination in C, C++, and Hack. It integrates formal proof-driven modular analysis, safety-preserving under-approximate reasoning, and an efficient static analysis architecture—overcoming traditional bottlenecks in code size and complexity. Contribution/Results: The framework achieves end-to-end analysis on industrial-grade open- and closed-source codebases totaling over 100 million lines. It discovers more than 30 previously unknown non-termination bugs—demonstrating unprecedented practicality and scalability for divergence detection. By enabling precise, compositional non-termination proofs at scale, it establishes a new benchmark for divergence verification in massive software systems.

Technology Category

• Reasoning under Uncertainty: Probabilistic Programming
• Constraint Satisfaction and Optimization: Satisfiability Modulo Theories
• Machine Learning: Scalability of ML Systems

Application Category

• Security and Privacy: Large-scale security measurements
• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Web Mining and Content Analysis: Web data provenance, reliability, and authenticity

Abstract

We report on our tool, Pulse Infinite, that uses proof techniques to show non-termination (divergence) in large programs. Pulse Infinite works compositionally and under-approximately: the former supports scale, and the latter ensures soundness for proving divergence. Prior work focused on small benchmarks in the tens or hundreds of lines of code (LoC), and scale limits their practicality: a single company may have tens of millions, or even hundreds of millions of LoC or more. We report on applying Pulse Infinite to over a hundred million lines of open-source and proprietary software written in C, C++, and Hack, identifying over 30 previously unknown issues, establishing a new state of the art for detecting divergence in real-world codebases.

Problem

• Proving non-termination in large-scale software programs
• Addressing scalability limitations of prior divergence detection methods
• Identifying unknown divergence issues in real-world codebases

Innovation

• Proof techniques for non-termination proving
• Compositional and under-approximate analysis approach
• Scalable application to 100+ million LoC