static-analysis

Detect security and data-flow vulnerabilities using LLVM static analysis techniques.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you reason about security and correctness issues in code by performing LLVM-based static analysis, so you can detect vulnerabilities and risky behaviors without executing the program.

Core Features & Use Cases

  • Dataflow analysis: perform forward and backward analyses plus may/must approximations to understand how values propagate.
  • Control flow analysis: use dominator and post-dominator trees and loop information to model program structure and dependencies.
  • Pointer and taint analysis: apply alias/points-to reasoning (including Andersen/Steensgaard-style approaches) and implement source-to-sink taint propagation for information-flow and vulnerability detection.
  • Program verification workflows: build data dependence graphs and slicing to support auditing, debugging, and research-grade static reasoning.
  • Security applications: flag patterns like buffer overflows (e.g., via range checks around GEP/indexing), use-after-free (allocation/deallocation tracking), and sensitive data leaks to dangerous sinks.

Quick Start

Use the static-analysis skill to design and implement an LLVM pass that propagates taint from specified sources to sensitive sinks and reports potential vulnerabilities for each function.

Frequently Asked Questions about static-analysis

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

FAQPage Schema
How do I detect security vulnerabilities using LLVM static analysis?

LLVM static analysis detects vulnerabilities by implementing source-to-sink taint propagation and tracking dataflow across functions. You configure propagation rules to flag risky behaviors like buffer overflows and use-after-free without executing the program.

What is taint tracking and how does it work for information-flow analysis?

Taint tracking is an information-flow analysis technique that propagates data from specified sources to sensitive sinks. It uses may/must approximations and alias analysis to determine if untrusted inputs reach dangerous operations.

How do I implement an LLVM pass for interprocedural dataflow analysis?

Implement an LLVM pass by integrating analysis managers like dominator trees and loop info, then building data dependence graphs for interprocedural handling. This models program structure to support forward and backward analyses across function boundaries.

Does LLVM alias analysis support Andersen-style points-to reasoning for pointer tracking?

LLVM alias analysis supports points-to reasoning for pointer tracking, enabling Andersen or Steensgaard-style approaches. This alias information is crucial for accurately modeling pointer behavior during taint propagation and vulnerability detection.

Can I use control flow analysis with dominator trees for code quality auditing?

Control flow analysis uses dominator and post-dominator trees plus loop information to model program dependencies for code quality auditing. Combined with program slicing, it supports debugging and research-grade static reasoning across functions.

What are the limitations of static analysis for detecting use-after-free bugs?

Static analysis for use-after-free relies on allocation and deallocation tracking approximations, which may produce false positives. Limitations arise from complex alias relationships and interprocedural control flow that obscure precise deallocation boundaries.