Heob | Qt Creator Documentation
Description: Detect memory leaks with Heob.

- Qt Creator Documentation
- Heob
- Qt Creator 19.0.0

Chrome Trace Format Visualizer ◦ JavaScript and QML checks

# Heob

Detect memory leaks with Heob.

To specify settings for Heob, go to Analyze > Heob.

In Extra arguments, enter additional arguments for running Heob. To list the available arguments in the Heob console, enter `-H` in this field and select Enter.

For example, use the `-oleaks.html` option to record leak data in an HTML file. Together with this option, you can use the `-g2` option to group the leaks visually in the file and the `-L1024` option to record leak contents up to 1024 bytes in the file. For example, `-oleaks.html -g2 -L1024`

To save your changes as default settings, select .

To remove a customized settings profile, select the profile, and then select Delete.

The following sections describe the available options in more detail.

## Recording results

The results of the checks are displayed in the Memcheck view and recorded in a file. Specify the file name in XML output file. Heob creates the file in the project directory.

You can use the process identifier (PID) as a variable in the file name. For example, `leaks-%p.xml`. This injects Heob into the child processes, as well.

Other variables you can use are `%P` for the parent PID and `%n` for the application name.

If you use variables, Qt Creator cannot open the file automatically, but you can open it from the project directory.

## Handling exceptions

In Handle exceptions, select Off to use the standard exception handler and have the debugger automatically attached if the application crashes. This works only if you register Qt Creator is as a post-mortem debugger by selecting Preferences > Debugger > General > Use Qt Creator for post-mortem debugging.

Select On to use the Heob exception handler that checks the reason and location of the crash and detects whether it occurred because of buffer overrun.

Select Only to disable all Heob functions, except installing the exception handler. If the application crashes, only a stack trace of the crash is displayed. Therefore, this option is mostly useful when using Heob on the console or running it for child processes, as well.

## Raising exceptions on errors

Select the Raise breakpoint exception on error check box to display errors when the application runs.

If the option is disabled, errors such as double free, free of invalid pointer, and not enough memory just write all collected data into the results file and you will only see them at the end of the application run.

If the option is enabled, the application stops at the error location. This is mostly useful when used with the Run with debugger option, which runs Heob under the debugger.

## Protecting pages

In Page protection, select Off to use standard memory allocation functions and enable only memory leak detection.

Select After to place a protected page at the end of each allocated block and throw an exception if it is accessed. Select Before to place a protected page before each allocated block. These options consume memory and slow down the checks, and are therefore recommended only for 64-bit or short-running programs.

Select Freed memory protection to protect all allocation pages when freed, so that their address space can never be used again. This is useful for use-after-free and double-free detection. However, the available memory address space can run out fast for 32-bit programs.

## Handling leak data

In Leak details, determine how to handle the collected leak data when the process exits. Selecting None means that no leak data is collected. If you activate leak type detection, Heob might need more time to collect the data when the process exits.

Select Simple to write all memory that was not freed into the results file.

Select Detect Leak Types to parse all static and global memory blocks for references to the leaks. The reachable blocks are marked reachable and recursively checked for other references. If references are found, the blocks are marked indirectly reachable. The remaining blocks are checked for references to each other and marked either indirectly lost or jointly lost (if the blocks reference each other). The blocks that have no references at all are marked lost. Select Detect Leak Types (Show Reachable) to also record the the reachable blocks in the results file.

Select Fuzzy Detect Leak Types to mark memory blocks reachable or indirectly lost if they have references to any address. This option is useful when used with some custom allocators (such as `av_malloc()` in `ffmpeg`) that keep only an address somewhere inside the allocation block and do not refer directly to the start of an allocated block. Select Detect Leak Types (Show Reachable) to also record the reachable blocks in the results file.

In Minimum leak size, select the size of leaks to detect in bytes.

In Control leak recording, select Off to record all leaks. You cannot change leak recording while it is running.

To start Heob without starting leak recording, select On (Start Disabled). In the Heob console, turn recording on or off, clear all results, or select show to record all current leaks into the results file. Open the file to see its contents before the process exits.

To start leak recording when Heob starts and still have the option to control the recording, select On (Start Enabled).

See also Detect memory leaks with Heob, How to: Analyze, Analyzers, and Analyzing code.

Chrome Trace Format Visualizer ◦ JavaScript and QML checks