GNU nm

Demangles C++ symbol names into readable function and class names.

nm -C libfoo.a

Very common in C++ projects.

—

Shows only external or global symbols.

nm -g main.o

Useful when local symbols are irrelevant and only exported/imported symbols matter.

—

Shows only undefined symbols.

nm -u main.o

This is especially useful when diagnosing linker errors.

—

Shows only defined symbols.

nm -U libfoo.a

Useful when checking what a file or library actually provides.

—

Shows dynamic symbols rather than the normal symbol table.

nm -D libfoo.so

Important for shared libraries and dynamically linked executables.

—

Sorts symbols by numeric address rather than by name.

nm -n a.out

Useful for understanding layout in address order.

—

Prints the file name before each symbol.

nm -A *.o

Useful when inspecting many files at once.

—

Tries to display source file and line number information.

nm -l a.out

Works best when debug information is present.

—

Prints symbol size in addition to value.

nm -S a.out

Useful for code size or object size inspection.

—

Sorts symbols by size.

nm --size-sort -S a.out

Useful for finding large functions or objects.

—

Includes debugger-only symbols.

nm -a a.out

Less common in everyday work, but useful for full inspection.

—

A common linker error is:

undefined reference to `foo`

To inspect unresolved references in an object file:

nm -u main.o

To search for the file or library that defines foo:

nm libfoo.a | grep ' foo$'

This is one of the classic uses of nm.

—

For a static library:

nm -g libmylib.a

For a shared library:

nm -D -g libmylib.so

This helps identify the API visible to other code.

—

To inspect what a single object file contains:

nm file.o

This reveals:

• which functions are defined
• which global variables are defined
• which symbols are still unresolved
• what section each symbol belongs to

This makes nm very useful for learning compilation and linking.

—

C++ binaries often contain mangled names. The following form makes them readable:

nm -C a.out

This is useful for examining namespaces, overloaded functions, class methods, and template instantiations.

—

When symbol resolution behaves unexpectedly, nm can reveal whether a symbol is weak or strong.

Weak symbols often appear as:

• W
• w
• V
• v

This is useful in runtime libraries, low-level systems code, and large C/C++ projects.

—

For static libraries, the archive symbol index can be displayed with:

nm -s libfoo.a

This is helpful when studying how symbol lookup works inside .a archives.

—

For shared libraries or dynamically linked executables:

nm -D libfoo.so

This focuses on the dynamic symbol table, which is especially relevant for runtime linking.

—

To inspect symbols together with size information:

nm -S --size-sort a.out

This is useful for:

• code size optimization
• embedded systems work
• tracking binary growth
• locating unusually large functions or objects

—

When debug information is available:

nm -l a.out
nm -l --inlines a.out

This can associate symbols with source file and line information.

—

GNU nm supports plugins and can be used with LTO-related objects.

Example:

nm --plugin /path/to/plugin file.o

This is relevant in more advanced toolchain setups where ordinary nm output may not fully expose LTO-generated symbol information.

—

GNU nm supports different output styles, including:

• bsd
• sysv
• posix
• just-symbols

Examples:

nm -f sysv a.out
nm -P a.out
nm -j a.out

These are useful for:

• scripting
• portability
• machine-friendly output
• compatibility with other tools

—

When analyzing many object files or archive members:

nm -A *.o
nm -A libfoo.a

This makes it easier to determine which file contributes which symbol.

—

GNU nm can also show linker-generated or target-specific symbols:

nm --synthetic a.out
nm --special-syms a.out

This is mainly useful in advanced ABI, linker, or target-format investigation.

—