Illegal deallocation of memory

The illegal deallocation of memory occurs when a free operation is performed on a pointer that doesn't point to an appropriate heap memory segment. This type of error can occur when you attempt to do any of the following activities:

• free a NULL pointer (not detected)
• free a pointer to stack or static memory
• free a pointer to heap memory that does not point to the beginning of an allocated block
• perform a double free (when free) is performed more than once on the same memory location)

Consequences

The illegal deallocation of memory can generate the following runtime errors:

• memory corruption (a stack, heap, or static segment)
• immediate segmentation fault

Detecting the error

In the QNX IDE, the Memory Analysis tool detects this error (if error detection is enabled), and it traps the illegal deallocation error when any of the following functions are called:

• free
• realloc

Enabling error detection for the illegal deallocation of memory

To enable error detection for the illegal deallocation of memory:

1. In the Launch Configuration window, select the Tools tab.
2. Expand Memory Errors and select the Enable error detection checkbox.
3. Select the Enable check on realloc()/free() argument checkbox.
4. Click OK.

Message returned to the QNX IDE

In the IDE, you can expect the message for this type of memory error to include the following types of information and detail:

• Message: Pointer does not point to heap area
• Severity: ERROR
• Pointer: 0 (typically 0 for most messages)
• TrapFunction: shows the free or realloc function where the error occurred.
• Operation: shown, where applicable

For a list of error messages returned by the Memory Analysis tool, see Summary of error messages for Memory Analysis.

How to address the illegal deallocation of memory

To help address this memory problem, try the following:

• Add a condition to test that when a NULL is a pointer, to verify that it can be freed.
• Don't free stack and static memory. Ensure that the same pointer can never point to different types of memory.
• Never reassign an allocated pointer (except for a NULL or other allocation). If you need to iterate over allocated memory, use another pointer (alias), or just use an index.
• Nullify the pointer immediately after deallocation, unless it is a local variable which is out of scope.

Example

The following code shows an example of the illegal deallocation of memory:

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
                     
int main(int argc, char ** argv){ 
char * str = ""; 
if (argc>1) { 
str = malloc(10); 
// ... 
} 
printf("Str: %s\n",str); 
free(str); 
return 0; 
}