Linker Map Viewer & Map File Analyzer (GNU ld, Memory Usage)

Zovo

3 installs

Opens linker map files (.map) from GNU ld, LLVM lld, IAR and Keil as FLASH and RAM usage bars, sortable tables of sections, object files and symbols, a treemap, and a compare of two builds that shows what grew. Reads 200 MB maps in a background thread. Free, no sign-in, works offline.

Installation

Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.

Copied to clipboard

More Info

Linker Map Viewer & Map File Analyzer (GNU ld, Memory Usage)

See where your FLASH and RAM go. Click a .map file from GNU ld, LLVM lld, IAR or Keil and get memory region bars, sortable tables of sections, object files and symbols, a treemap, and a compare of two builds. Free, no sign-in, works offline.

An ESP-IDF map in Linker Map Viewer: four memory regions with bars split into code, read-only data, data and zero-init, then totals and the biggest object files and symbols

What you get

Memory regions from the Memory Configuration table, each with a used/total bar split into code, read-only data, initialized data and zero-init data. The numbers equal ld --print-memory-usage, and a region over its size turns red.
Tables of output sections, object files, libraries (.a archives), symbols, input sections and discarded sections. Sort by any column, filter with words or a /regex/, and scroll through a million rows.
Click an object file to see its sections and why the linker pulled it in ("main.o needs uart_init"). Click a symbol to see its address, size, section and, with --cref, which files use it.
Double-click a symbol or object file to open its source file in the workspace at the definition (uart.o and uart.c.obj find uart.c).
A treemap of region, section, library and object file sizes. Click a box to go in.
Compare with the map of an older build: the change of every region, section, object file and symbol, biggest first. Export as CSV or Markdown for a pull request.
Sizes in bytes, KB or hex. Dark and light themes follow VS Code.

The Symbols table filtered to "uart", sorted by size, with the details of one symbol on the right

Formats

Linker	Typical source	What the viewer reads
GNU ld	gcc, arm-none-eabi-gcc, ESP-IDF, Zephyr, Raspberry Pi Pico SDK, STM32CubeIDE, avr-gcc, RISC-V	memory regions, sections, input sections, symbols, discarded sections, archive reasons, cross references
LLVM lld	clang, Rust embedded	sections, input sections, symbols with sizes; regions from `memory.x` or a `*.ld` script next to the map
IAR ILINK (7.x, 8.x)	IAR Embedded Workbench	placement blocks and ranges, sections, entry list
Arm Compiler armlink (5, 6)	Keil MDK	execution and load regions, sections, symbol table, removed sections, "Grand Totals"

The format is found from the file's first lines. A .js.map or .css.map source map stays a JSON text file. Any other JSON file that ends in .map goes back to the text editor with a short message.

Make your linker write a map

# GCC / arm-none-eabi-gcc / clang (add --cref for the "used by" list)
arm-none-eabi-gcc ... -Wl,-Map=firmware.map,--cref
# CMake
target_link_options(app PRIVATE -Wl,-Map=firmware.map)
# Rust (cortex-m)
RUSTFLAGS="-C link-arg=-Map=firmware.map" cargo build --release

IAR: --map firmware.map. Keil: --map --list=firmware.map. ESP-IDF, Zephyr, the Pico SDK and PlatformIO already write one into the build folder.

Large maps

The file is read in 4 MB chunks in a background thread, never as a whole into VS Code or the view. In our test, a 206 MB GNU ld map with 1.1 million symbols showed its first progress in under a second and its full summary in 3 to 5 seconds. The editor keeps working while it reads. Only the rows on screen are sent to the view.

Compare two builds

Compare: before and after totals, region changes, and the symbols that changed, biggest first

Click "Compare..." in the toolbar and pick the older map, or select two .map files in the Explorer and pick "Compare Linker Maps". "Changed only" hides the rest, and "Swap" turns before and after around.

Why this one

These are problems reported on other map file extensions. Each one is checked by a test in this repo:

Report	What Linker Map Viewer does
An IAR 9.60 map does not open (open since 2026-06-19)	Reads IAR ILINK maps. Tested on two public IAR 7.50 and 8.40 maps: the ROM region totals equal IAR's own "bytes of readonly code/data memory" lines.
The "Cross Reference Table" heading is not recognized (open since 2025-02-15)	Reads the cross reference table from `--cref`. Each symbol's details list the files that use it.
Discarded input sections counted in memory regions (fixed there in 2026)	Discarded sections get their own tab and are never counted in a region. On the test maps every region total equals `ld --print-memory-usage`.
Section names without a leading dot, or with `$$`, merged into the previous section (fixed there in 2026)	`ram_noinit` and `__ram_noinit$$` are sections of their own, with the right sizes.
No build for the Open VSX registry (open since 2021-07-25)	Plain JavaScript with no native code, and `engines.vscode ^1.90.0`, so VSCodium, Cursor and Windsurf can install it.

One more check: with .data : AT(addr) placement, ld --print-memory-usage leaves the .data load copy out of FLASH. Linker Map Viewer counts it (nRF52 test map: 2,500 bytes, the same as size text + data plus 1 alignment byte).

Settings

Setting	Default	What it does
`linkerMap.sizeFormat`	`bytes`	Sizes as bytes, KB or hex when a map opens
`linkerMap.warnAbovePercent`	`90`	A region bar turns to the warning color above this percentage
`linkerMap.readLinkerScript`	`true`	For maps without regions (lld, Rust), read the MEMORY block of a nearby linker script
`linkerMap.memoryRegions`	`[]`	Regions to use for such maps, for example `[{"name": "FLASH", "origin": "0x08000000", "length": "512K"}]`
`linkerMap.maxRemoteMB`	`512`	Largest map read from a remote or virtual file system
`linkerMap.askForRating`	`true`	One rating question after a few days of use
`linkerMap.showSupportLinks`	`true`	The small Rate, More free viewers and Sponsor links

Privacy

No network requests, no telemetry, no account. The view has a strict content security policy (default-src 'none'). The map is read on your machine and nothing leaves it.

Notes

GNU ld maps list global symbols without sizes. A size marked ~ runs from the symbol to the next symbol in the same input section (exact with -ffunction-sections -fdata-sections). Static symbols are not in GNU ld maps.
IAR splits a few bytes between "code" and "read-only data" its own way, so those two lines can differ from IAR's summary by a few bytes. Their sum matches.

Support Zovo

Zovo extensions are free, with no ads and no tracking. They are made by theluckystrike on GitHub. If this one saves you time, you can support the work:

More tools by Zovo

ZIP Viewer & Archive Explorer (JAR, TAR, GZ) browses ZIP, JAR, VSIX, TAR and GZ files, opens entries in tabs and extracts them safely.
Hex Viewer & Binary Viewer, Hex Editor (Large Files) Hex viewer, binary viewer and hex editor for VS Code that opens files of any size (4 GB and more) in under a second. Insert and delete bytes, compare two files byte by byte, go to offset, find hex or text, a data inspector, copy as C array or base64. Free, works offline.
Large JSON Viewer, JSON Browser & JSON Tree shows large JSON files as a searchable tree, copies JSONPath and turns arrays of objects into a table.
SQLite DB Viewer & SQLite Viewer, Database Viewer (Read-Only) browses SQLite tables read-only and runs SELECT queries.
Graphviz Viewer & DOT Viewer (Live Preview) shows a live preview of DOT files and exports SVG or PNG.

See all Zovo extensions on the Marketplace.

License

MIT