Symbolic Execution Tool for C++ Software Validation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current software testing methods, such as regression testing, often fail to detect corner-case bugs and provide limited coverage, while existing symbolic execution tools for C++ are inefficient due to lack of good abstractions, fast solvers, and domain-specific handlers.
Innovation Solution
A symbolic execution and automatic test generation tool for C, C#, and C++ software that compiles programs into LLVM bytecode, uses customized low-level libraries, and implements efficient solvers for common data structures, along with domain-specific handlers to optimize processing and generate high-coverage test cases.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If symbolic execution tools are used for C++ software validation, then testing coverage is improved, but execution efficiency deteriorates due to lack of good abstractions, fast solvers, and domain-specific handlers
Solution Approach 1:
The patent segments the C++ standard library into multiple abstraction levels (low-level libraries vs. standard library) and processes them differently during symbolic execution. Low-level libraries are executed concretely while standard library calls are handled symbolically, dividing the execution workload to improve efficiency while maintaining coverage.
Solution Approach 2:
The patent changes the execution mode parameter for different library levels - low-level libraries use concrete execution mode while standard libraries use symbolic execution mode. This parameter differentiation allows the system to optimize performance for critical sections while maintaining thorough testing coverage for higher-level abstractions.
2Reliability
If exhaustive symbolic execution is performed on all input values, then bug detection capability is improved, but processing time increases significantly
Solution Approach 1:
The patent performs preliminary concrete execution of low-level library functions to establish baseline behavior and cached results before symbolic execution proceeds. This preliminary action reduces redundant symbolic analysis and accelerates the overall bug detection process while maintaining exhaustive coverage where needed.
Solution Approach 2:
The patent introduces an intermediary layer (low-level libraries) that bridges concrete execution and symbolic execution. This intermediary handles time-consuming operations concretely, acting as a buffer that reduces the symbolic execution burden and overall processing time while preserving bug detection capability through the symbolic layer.
3Adaptability or versatility
If C++ programs are compiled and linked with standard libraries for symbolic execution, then program functionality is preserved, but execution speed deteriorates due to lack of optimization
Solution Approach 1:
The patent segments the library ecosystem into standard C++ libraries (for functionality and adaptability) and customized low-level libraries (for speed optimization). This segmentation allows the system to maintain full program functionality through standard libraries while achieving execution speed improvements through optimized low-level implementations.
Solution Approach 2:
The patent creates customized copies of low-level library implementations that are optimized for symbolic execution performance. These copied and adapted low-level libraries maintain the same interface and functionality as standard libraries but are optimized for the symbolic execution context, improving execution speed without sacrificing functionality.
Data Source
AI summary
Particular embodiment compile a C++ program having one or more input variables to obtain bytecode of the C++ program; compile a C++ library to obtain bytecode of the C++ library; symbolically execute the bytecode of the C++ program and the bytecode of the C++ library, comprising assign a symbolic input to each input variable of the C++ program; determine one or more execution paths in the C++ program; and for each execution path, construct a symbolic expression that if satisfied, causes the C++ program to proceed down the execution path; and generate one or more test cases for the C++ program by solving the symbolic expressions.