Jump to content

Insure++: Difference between revisions

From Wikipedia, the free encyclopedia
Content deleted Content added
added section header
No edit summary
Line 22: Line 22:
int main()
int main()
{
{
char *p = [[malloc]](1024); /* first dynamically-allocated block */
char *p = malloc(1024); /* first dynamically-allocated block */
char *q = malloc(1024); /* second block */
char *q = malloc(1024); /* second block */
p += 1200; /* At this point, "p" is very (un)likely to point into the second block.
p += 1200; /* At this point, "p" is very (un)likely to point into the second block.

Revision as of 23:51, 17 November 2007

Insure++
Developer(s)Parasoft
Stable release
7.1.1 / June 2, 2007
Operating systemCross Platform
TypeProfiler / Memory debugger
LicenseProprietary software
WebsiteInsure++ at Parasoft.com

Insure++ is a memory debugger computer program, used by software developers to detect various errors in programs written in C and C++. It is made by Parasoft, and is functionally similar to other memory debuggers, such as Purify and Valgrind.

Overview

Insure++ can automatically find erroneous accesses to free()d memory, array bounds violations, freeing unallocated memory (which often happens when a programmer free()s the same memory twice, or when he free()s global or stack memory), and many others.

Unlike Purify and Valgrind, Insure++ inserts its instrumentation at the source code level, which allows it to detect errors that the other tools miss. In particular, Insure++ can detect buffer overflows in automatic arrays, and overflows which involve pointers that accidentally "jump" from one valid memory region to another, as in the following example:

#include <stdlib.h>
int main()
{
   char *p = malloc(1024); /* first dynamically-allocated block */
   char *q = malloc(1024); /* second block */
   p += 1200; /* At this point, "p" is very (un)likely to point into the second block. 
                 False assumptions about the real behaviour lead to mistakes. */
   *p = 'a';  /* invalid write (past the end of the first block) */
   return 0;
}

Also the source level instrumentation allows it to not only identify that a leak occurred, but where it occurred. Some tools merely provide information about where the memory was allocated, Insure++ also gives a stack trace for when/where the actual leak occurred.