Call Graph Verification for Function Pointer Detection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Traditional automated systems for software code verification are unable to identify function pointers between functions and focus only on code syntax, missing important design semantic violations.
Innovation Solution
The system generates a call graph using intermediate code and user input, representing functions, function calls, and register information, allowing for the analysis of function pointers and conformance to design specifications.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If traditional automated systems analyze only source code syntax, then code verification is simple and fast, but design semantic violations cannot be detected
Solution Approach 1:
The patent introduces an intermediary representation layer (call graph) that sits between the source code and the verification rules. This call graph captures function pointers and control flow relationships, enabling the system to detect design semantic violations without requiring complex direct analysis of source code. The intermediary representation transforms the verification problem into a graph-based analysis that is both precise and computationally manageable.
2Reliability
If manual code inspection is performed at every phase and level, then design specification compliance is thoroughly checked, but time and effort requirements increase significantly
Solution Approach 1:
The system performs preliminary action by automatically generating the call graph representation before verification rules are applied. This pre-computed structure captures all function pointers and control flow relationships in advance, enabling rapid verification rule checking without requiring repeated manual inspections at each development phase. The preliminary graph construction allows multiple verification passes to be performed efficiently on the same structural representation.
3Adaptability or versatility
If conventional automated systems focus only on code syntax rules, then verification is straightforward, but violations of design-specific rules cannot be identified
Solution Approach 1:
The patent transitions from one-dimensional source code text analysis to a two-dimensional graph-based representation where nodes represent functions and edges represent call relationships. This dimensional change enables the system to detect design-specific rules (such as function pointer usage patterns and control flow constraints) that cannot be identified through linear code syntax analysis alone, while maintaining computational tractability through graph algorithms.
Data Source
AI summary
In various examples, techniques for performing software code verification are described. Systems and methods are disclosed for generating, using intermediate code and user input, a call graph that represents source code for software. For instance, the call graph represents at least functions (e.g., internal functions, external functions, etc.) associated with the software, calls (e.g., direct calls, call pointers, etc.) between the functions, and register information associated with the functions (e.g., variables used by the functions, assembly code used by the functions, etc.). The systems and methods may further use the call graph to perform software code verification by verifying rules from design specifications for the software and/or rules from various certification standards.