// //

Want to see Parasoft in action? Sign up for our Monthly Demos! See Demos & Events >>

X
C/C++ Memory Debugging

C and C++ Memory Debugging

Identify sporadic memory corruption and defects that cause system crashes and expose security vulnerabilities.

The Ultimate Memory Debugger for C and C++

Parasoft Insure++ is a comprehensive memory debugging tool for C and C++ software developers. You can find erratic programming and memory-access errors, such as heap corruption, rogue threads, memory leaks, array out of bounds, and invalid pointers. Using a state-of-the-art code parser and hundreds of heuristics, Parasoft Insure++ also analyzes the application code and reports on several possible static violations.

Parasoft中国官网|C/C++ Memory Debugging

How Does It Work?

Parasoft Insure++ is a runtime memory analysis and error-detection tool for C and C++ that automatically identifies a variety of difficult-to-find programming, memory-access, and security errors, along with potential defects and inefficiencies in memory usage.

During testing, Insure++ checks all types of memory references, including those to static (global), stack, and shared memory in either the user’s code or in your third-party libraries.

Parasoft’s Insure++’s memory analysis capabilities are based on patented source instrumentation algorithms. Source code instrumentation enables Insure++ to detect more error types than other memory error detection technologies, and provides complete information indicating the root causes of the errors found, using a full database of program elements and memory structures. There are two ways to use Insure++ for memory analysis and error detection.

Source Instrumentation Mode

The first and most detailed analysis is achieved with full source-code instrumentation. This requires that application sources be compiled and linked with Insure++, which generates its own instrumented files that are passed to the actual compiler.

Link Mode

Without source code instrumentation, by linking your application object code and libraries with Insure++, the tool can “spy” on the kernel/application program interface to detect errors such as leaks, bad memory references, standard API usage errors, and so on.

Features

During runtime debugging, Parasoft Insure++ checks all your memory references, including those to static (global), stack, and shared memory — both in your own code and in third-party libraries.

  • Corrupted heap and stack memory
  • Use of uninitialized variables and objects
  • Array and string bounds errors on heap and stack
  • Use of dangling, NULL, and uninitialized pointers
  • All types of memory allocation and free errors or mismatches
  • All types of memory leaks
  • Type mismatches in global declarations, pointers, and function calls

At compile time, Parasoft Insure++ detects errors by identifying deviations from C/C++ standards that may lead to memory leaks or application instabilities.

  • Cast of pointer loses precision
  • Mismatch in format specification
  • Mismatch in argument type
  • Code is not evaluated, has no effect, or is unreachable
  • Undefined identifier
  • Variable declared, but never used
  • Returning pointer to local variable
  • Function returns inconsistent value
  • Unused variables

Parasoft Insure++’s coverage analysis enables the visual identification of which sections of code have been executed and which have not. This capability allows users to focus on testing use-cases for the areas of code that haven’t yet been exercised. Insure++ can also add a “hit count” to the basic blocks, showing how many times each block has executed to detect surprising performance bottlenecks.

Software developers get a graphical view of live data about ongoing memory usage and memory allocations over time with specific visibility into overall heap usage, block allocations, possible outstanding leaks, and so on. If a block has been leaked, you can see the allocation stack trace, as well as the stack trace where the leak occurred. The overall size of the heap is monitored, and various statistics are tracked like the number of allocation and deallocation calls.

Parasoft Insure++ reports any problems found. The detailed information you get includes the type of bug, source file and line number, actual source code line contents, expression that caused the problem, and information about all pointers and memory blocks involved in the bug. Software developers can also see pointer values, memory blocks pointed to, block allocation information, and the stack trace showing how the program got to the bug location.

Most projects are large and contain multiple files. Nevertheless, there are times when you will need to investigate only a handful of those files for suspected runtime violations. This is done when Parasoft Insure++ instruments the individual files that you decide to investigate. The individual files can then get linked to a non-instrumented executable. This finds errors in the files in question at the source level with minimum effort.

Benefit From the Parasoft Approach

Find the Root Cause of Security Issues

With an increased awareness that security is no longer an optional consideration, it is critical to ensure that your applications are secure at the core. Use Parasoft Insure++ to protect from root security vulnerabilities stemming from memory issues, such as heap corruption, pointer abuse, buffer overflows, uninitialized memory, and undefined or implementation defined behavior.

Manage & Debug Your Memory Usage

Parasoft Insure++ helps users pinpoint where memory issues are, while providing tools to identify what’s going on both within the code and the memory. With built-in coverage analysis and dynamic memory visualization, you can find areas of the code that need to be exercised to check for errors and locate causes of heap fragmentation.

Find Memory Issues in Minutes

Successfully discover high risk bugs for business and safety-critical applications across industries like financial, transportation, automotive, aerospace and medical. Software development teams can find plaguing issues in weeks — or even minutes — with Parasoft Insure++.

Problems that use to take us several days or even weeks to track down, we are able to routinely find and fix in a few hours with Insure++.

- Hewlett Packard