# svf-tools/svf

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/svf-tools-svf).**

_How this analysis was created: the description and tags below were written by an AI model that read this project's README and public documentation pages; stars, license and language come straight from the GitHub API. The model does not read the source code._

1,684 stars · 493 forks · C++ · NOASSERTION

## Links

- GitHub: https://github.com/SVF-tools/SVF
- Homepage: http://svf-tools.github.io/SVF/
- awesome-repositories: https://awesome-repositories.com/repository/svf-tools-svf.md

## Topics

`code-analysis` `code-security` `dependency-analysis` `llvm` `pointer-analysis` `points-to-analysis` `source-code-analysis` `static-analysis` `static-analyzer` `static-value-flow`

## Description

SVF is an open-source static program analysis framework and points-to analysis library that tracks memory references, variable aliases, and data dependencies across whole programs. The platform translates compiled intermediate code formats into unified internal representations, constructing constraint graphs, call graphs, and control-flow graphs to model interprocedural execution behavior and memory state. 

The framework incorporates specialized engines for flow-sensitive, flow-insensitive, and context-sensitive pointer analysis alongside sparse value-flow graph generation. It features memory layout modeling, static single assignment conversions for address-taken variables, and points-to set deduplication primitives designed to conserve system memory during large-scale program evaluations. Performance optimization utilities cache calculation results and short-circuit redundant computations through indirect identifiers, while parallel execution capabilities distribute analysis workloads across multiple threads.

The software supports comprehensive static analysis tasks including software vulnerability detection, memory safety error identification, information flow tracking, and multithreaded program analysis. Users can generate detailed metrics, export graph visualizations in standard formats, and query program dependence information using custom driver scripts. The library can be compiled from source or deployed within containerized environments.

## Tags

### Programming Languages & Runtimes

- [Pointer Analysis Executors](https://awesome-repositories.com/f/programming-languages-runtimes/pointer-analysis-frameworks/pointer-analysis-executors.md) — Executes pointer analysis algorithms on source code to compute points-to relations across programs. ([source](https://github.com/svf-tools/SVF/wiki/User-Guide))
- [Source Pointer Trackers](https://awesome-repositories.com/f/programming-languages-runtimes/pointer-analysis-frameworks/source-pointer-trackers.md) — Calculates memory pointer relationships across programs using sensitive algorithms to trace data flow. ([source](http://svf-tools.github.io/SVF/))
- [Program Graph Constructions](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-optimization/whole-program-analysis/program-graph-constructions.md) — Transforms program instructions into constraint graphs where nodes represent pointers and edges represent dependencies. ([source](https://github.com/svf-tools/SVF/wiki/Technical-documentation))
- [Constraint Graph Solvers](https://awesome-repositories.com/f/programming-languages-runtimes/constraint-based-value-analysis/constraint-graph-solvers.md) — Builds constraint graphs for inclusion-based pointer analysis by iteratively resolving and adding copy edges. ([source](https://github.com/svf-tools/SVF/wiki/Analyze-a-Simple-C-Program))
- [Customizable Solvers](https://awesome-repositories.com/f/programming-languages-runtimes/context-sensitive-analysis/customizable-solvers.md) — Determines points-to relationships using customizable data structures and algorithms such as flow-sensitive solvers. ([source](https://github.com/svf-tools/SVF/wiki/Technical-documentation))
- [Intermediate Representation Translation](https://awesome-repositories.com/f/programming-languages-runtimes/intermediate-representation-translation.md) — Converts source code into language-independent intermediate formats and builds internal code graphs. ([source](http://svf-tools.github.io/SVF/))
- [Interprocedural Pointer Analysis](https://awesome-repositories.com/f/programming-languages-runtimes/interprocedural-pointer-analysis.md) — Investigates memory pointer relationships, alias sets, and points-to relations using flow-insensitive and flow-sensitive solvers.
- [Pointer Relationship Mappers](https://awesome-repositories.com/f/programming-languages-runtimes/pointer-analysis-frameworks/pointer-relationship-mappers.md) — Transforms source code into constraint graphs and solvers to compute points-to information. ([source](https://github.com/svf-tools/SVF/wiki/SVF-Design))
- [Flow-Sensitive Analysis](https://awesome-repositories.com/f/programming-languages-runtimes/flow-sensitive-analysis.md) — Performs static points-to analysis on source code using versioned staged techniques to track pointer values accurately. ([source](https://github.com/SVF-tools/SVF/wiki/VSFS))
- [Intermediate Representation Analysis](https://awesome-repositories.com/f/programming-languages-runtimes/intermediate-representation-analysis.md) — Processes compiled intermediate representation files as input to execute static analysis passes. ([source](http://svf-tools.github.io/SVF/))
- [Interprocedural Control Flow Mappings](https://awesome-repositories.com/f/programming-languages-runtimes/interprocedural-pointer-analysis/interprocedural-control-flow-mappings.md) — Constructs connected function call boundaries and basic block transition paths to model whole-program execution behavior.
- [Memory](https://awesome-repositories.com/f/programming-languages-runtimes/machine-code-generation/intermediate-representations/static-single-assignment-forms/memory.md) — Converts address-taken variables and indirect memory accesses into explicit definition-use chains using inserted use and change functions.
- [Memory SSA Form Constructions](https://awesome-repositories.com/f/programming-languages-runtimes/machine-code-generation/intermediate-representations/static-single-assignment-forms/memory-ssa-form-constructions.md) — Annotates indirect memory accesses with explicit definition and use functions to convert address-taken variables into static single assignment form. ([source](https://github.com/svf-tools/SVF/wiki/Technical-documentation))
- [Custom Pointer Analysis Builders](https://awesome-repositories.com/f/programming-languages-runtimes/pointer-analysis-frameworks/custom-pointer-analysis-builders.md) — Constructs flow- and field-insensitive inclusion-based pointer analyses with concise driver programs. ([source](https://github.com/svf-tools/SVF/wiki/Write-your-own-analysis-in-SVF))
- [Memory Layout and Allocation Modelings](https://awesome-repositories.com/f/programming-languages-runtimes/static-memory-allocations/memory-layout-and-allocation-modelings.md) — Parses source code to construct symbol tables and abstract memory objects capturing structure fields, array strides, and allocation sites. ([source](https://github.com/svf-tools/SVF/wiki/Technical-documentation))

### Testing & Quality Assurance

- [Static Code Analysis](https://awesome-repositories.com/f/testing-quality-assurance/static-code-analysis.md) — Analyzes source code and intermediate representations to compute points-to information, build program graphs, and inspect dependencies.
- [Static Analysis](https://awesome-repositories.com/f/testing-quality-assurance/code-quality-review/static-analysis.md) — Examines source code to compute points-to relations, data dependencies, and value flows across whole programs. ([source](https://github.com/svf-tools/svf#readme))
- [Code Structure Visualizations](https://awesome-repositories.com/f/testing-quality-assurance/static-code-analysis/unreachable-code-analysis/execution-graph-analysis/code-structure-visualizations.md) — Produces call graphs and control flow graphs to visualize program structure and data dependencies. ([source](https://github.com/svf-tools/svf#readme))

### Part of an Awesome List

- [Static Analysis Frameworks](https://awesome-repositories.com/f/awesome-lists/devtools/static-analysis-frameworks.md) — An open-source static analysis framework that computes pointer points-to information, call graphs, and value-flow graphs for source code.
- [Vulnerability Detection](https://awesome-repositories.com/f/awesome-lists/security/vulnerability-detection.md) — Identifies security flaws, memory leaks, and unsafe operations by tracking data flows from sources to sensitive sinks.

### Development Tools & Productivity

- [Static Call Graph Generators](https://awesome-repositories.com/f/development-tools-productivity/static-call-graph-generators.md) — Constructs visual diagrams of function call relationships to illustrate interprocedural control flow. ([source](https://github.com/svf-tools/SVF/wiki/Analyze-a-Simple-C-Program))

### Operating Systems & Systems Programming

- [Points-To Analysis Engines](https://awesome-repositories.com/f/operating-systems-systems-programming/binary-execution-analysis/points-to-analysis-engines/points-to-analysis-engines.md) — A pointer analysis library that tracks memory references and variable aliases across whole programs using flow- and context-sensitive algorithms.
- [Points-To Calculators](https://awesome-repositories.com/f/operating-systems-systems-programming/binary-execution-analysis/points-to-analysis-engines/points-to-calculators.md) — Performs flow-insensitive or flow-sensitive analysis to determine memory locations referenced by pointers. ([source](https://github.com/svf-tools/SVF/wiki/Analyze-a-Simple-C-Program))

### Scientific & Mathematical Computing

- [Constraint Graph Solvers](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/optimization-solvers/constraint-solvers/constraint-graph-solvers.md) — Computes inclusion-based points-to relations by iteratively resolving copy edges over large constraint networks until reaching a fixed point.

### Security & Cryptography

- [Software Vulnerability Detectors](https://awesome-repositories.com/f/security-cryptography/software-vulnerability-detectors.md) — Identifies source-sink related programming errors and memory safety issues using abstract execution techniques. ([source](http://svf-tools.github.io/SVF/))
- [Sensitive Data Flow Detection](https://awesome-repositories.com/f/security-cryptography/sensitive-data-flow-detection.md) — Traces data movement from designated source points to sensitive sink targets using value-flow graph representations. ([source](https://github.com/svf-tools/SVF/wiki/Write-your-own-analysis-in-SVF))

### Software Engineering & Architecture

- [Control-Flow Graph Generation](https://awesome-repositories.com/f/software-engineering-architecture/control-flow-logic-models/control-flow-graph-generation.md) — Builds interprocedural control flow graphs that map out execution paths and basic block transitions. ([source](https://github.com/svf-tools/SVF/wiki/Analyze-a-Simple-C-Program))
- [Value-Flow Graph Generators](https://awesome-repositories.com/f/software-engineering-architecture/control-flow-logic-models/control-flow-graph-generation/value-flow-graph-generators.md) — A compiler-based tool that constructs sparse value-flow representations and control flow graphs to detect bugs, memory leaks, and information flows.
- [Sparse Value-Flow Graph Generations](https://awesome-repositories.com/f/software-engineering-architecture/control-flow-logic-models/sparse-value-flow-graph-generations.md) — Builds directed graphs capturing definition-use chains for top-level pointers and address-taken objects. ([source](https://github.com/svf-tools/SVF/wiki/Technical-documentation))
- [Value-Flow Graph Generations](https://awesome-repositories.com/f/software-engineering-architecture/control-flow-logic-models/value-flow-graph-generations.md) — Constructs interprocedural sparse value-flow graphs capturing definition-use chains for pointers and memory objects. ([source](https://github.com/svf-tools/SVF/wiki/Analyze-a-Simple-C-Program))
- [Sparse Value-Flow Graph Constructions](https://awesome-repositories.com/f/software-engineering-architecture/graph-construction-frameworks/sparse-value-flow-graph-constructions.md) — Builds directed graphs capturing precise data dependencies and variable modifications to enable scalable interprocedural taint and security tracking.
- [Value-Flow Mappers](https://awesome-repositories.com/f/software-engineering-architecture/control-flow-graph-visualization/value-flow-mappers.md) — Builds interprocedural side-effect annotations and alias sets using points-to results to track variable modification. ([source](https://github.com/svf-tools/SVF/wiki/SVF-Design))
- [Analysis Graph Exporters](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/dependency-injection/dependency-graph-construction/static-graph-exports/analysis-graph-exporters.md) — Generates analysis graphs including call graphs and value-flow graphs in standard formats for external rendering. ([source](https://github.com/svf-tools/SVF/wiki/User-Guide))
- [Program Visualizations and Metrics](https://awesome-repositories.com/f/software-engineering-architecture/program-visualizations-and-metrics.md) — Generates graph representations such as call graphs and value-flow graphs alongside performance and memory statistics.
- [Memory Error Detection](https://awesome-repositories.com/f/software-engineering-architecture/shared-memory-management/memory-access-breakpoints/memory-error-detection.md) — Identifies memory leaks, double frees, and other unsafe memory operations through static program analysis. ([source](https://github.com/svf-tools/svf#readme))
- [Program Dependence Query Engines](https://awesome-repositories.com/f/software-engineering-architecture/static-analysis/module-dependency-analysis/program-dependence-query-engines.md) — Inspects points-to relationships and program dependence information programmatically using custom driver scripts. ([source](https://github.com/svf-tools/SVF/wiki/Write-your-own-analysis-in-SVF))