Intel® Inspector User Guide for Windows* OS

ID 767798
Date 5/15/2022

A newer version of this document is available. Customers should click here to go to the newest version.

Document Table of Contents

Invalid Memory Access

Occurs when a read or write instruction references memory that is logically or physically invalid.

Problem type: Invalid memory access (Read)

Problem type: Invalid memory access (Write)


Code Location



Allocation site

If present, represents the location and associated call stack from which the memory block containing the offending address was allocated.


Deallocation site

If present, represents the location and associated call stack from which the memory block containing the offending address was deallocated.

The deallocation makes the access to the offending memory address logically invalid.


Read or Write

Represents the instruction and associated call stack responsible for the invalid access.

If no allocation or deallocation is associated with this problem, the memory address might be one of the following:

  • Logically invalid stack space (below the current stack pointer value)

  • Memory that is physically not allocated to the process

  • Memory that has been deallocated


The offset, if shown in the Code Locations pane, represents the byte offset into the allocated buffer where the Invalid memory access occurred.

C Examples

Heap example:

char *pStr = (char*) malloc(20);
strcpy(pStr, "my string"); // Invalid write to deallocated memory

Stack example (set Analyze stack accesses to Yes when you configure the analysis):

void stackUnderrun()
   char array[10];
   strcpy(array, "my string");
   int len = strlen(array) - 1;
   while (array[len] != 'Z') // Will read memory outside of array

Fortran Example

integer, allocatable :: i, b(:)
allocate( b(100))
! Body of Console1    
do i = 1, 100
    b(i) = i
end do
! Invalid write to deallocated memory    
b(1) = 1
Possible Correction Strategies


Do This

An invalid pointer dereference (corrupt or invalid value) occurs.

This is usually a logic error in a sequential algorithm.

For example, the pointer may increment past the end or decrement before the beginning of dynamically allocated memory. This pointer address value can be the address of memory that is marked invalid to access.

When dereferencing a pointer, ensure:

  • The pointer refers to a valid object.

  • Pointer arithmetic stays within the bounds of the dynamically allocated memory.

A stale reference to memory occurs.

You can easily recognize this situation if allocation and deallocation information is present.

For example, if a thread holds a pointer to the heap, and another thread releases the memory back to the heap, then all future accesses to this memory are invalid.

You need a clear concept of object ownership to ensure one thread does not mistakenly release an object back to the heap while another thread considers the pointer valid. Consider reference counting.

The Intel Inspector detects an invalid memory access when enhanced dangling pointer check is disabled.

Run another memory error analysis with enhanced dangling pointer check enabled to potentially report allocation and deallocation information.