---
title: objdump — security analysis and diagnostics
date: 2026-10-18
time: 12:00
model: admin
category: programs
author_type: human
summary: A core binutils tool that outputs sections, symbols, and disassembly of object files such as ELF and PE. Essential for inspecting build artifacts.
tags: program, Security analysis and diagnostics, objdump
---

A fundamental GNU binutils tool for displaying sections, symbols, and disassembly of executable and object files.

## Basic information

| Program name | objdump (object dump) |
| --- | --- |
| One-line description | A fundamental GNU binutils tool for displaying sections, symbols, and disassembly of executable and object files. |
| Development/maintenance | GNU Project (binutils) |
| Official homepage | https://www.gnu.org/software/binutils/ |
| Official documentation | https://sourceware.org/binutils/docs/ |
| Official download | https://ftp.gnu.org/gnu/binutils/ |
| Supported operating systems | Linux, macOS, Windows (toolchains such as MinGW) |
| License | GPL-3.0-or-later |
| Stable version | binutils 2.46 series (released 2026-02) — confirmed on 2026-10-18 |
| GitHub repository | https://sourceware.org/git/binutils-gdb.git |
| Category | Security analysis and diagnostics (tags: disassembly, object file, ELF analysis) |

## What is this program?

objdump is a command-line tool included in GNU binutils that prints section lists, symbol tables, and disassembly code of executable and object files (.o) in a human-readable form.

It is used as a basic tool when checking whether a compiled result was produced as intended (whether symbols remain, which libraries are linked), and when tracing link problems caused by library errors. It is also a familiar name to server administrators who inspect server programs built with gcc.

## What problems does it solve?

- When you need to verify that a built executable or object file has the correct structure.
- When you need to narrow down which function or code line an address in a crash log corresponds to.
- When you need to check which symbols and sections remain in a binary (such as whether debug symbols have been removed).
- When you need to record disassembly results as documentation or reports on a file basis without GDB.
## Key features

### Section and header information

Use the -h option to print the section list along with sizes and flags.

- **Use case**: Check the .text, .data, and .bss layout of an ELF file.
- **What you get**: A table of section layout and sizes.
- **Limitations**: readelf and GDB provide more detailed information for in-depth analysis.
### Disassembly

Use the -d option to convert a specified section from machine code to assembly.

- **Use case**: Examine code near the address where a crash occurred.
- **What you get**: The assembly instructions and symbol labels at that address.
- **Limitations**: Output can reach millions of lines, so piping through grep and less is essential.
### Symbol table output

Use -t to print the symbol list and -T to print dynamic symbols.

- **Use case**: Check dynamic linking targets (library functions).
- **What you get**: Narrow down the cause of link errors by checking for undefined symbols.
- **Limitations**: Stripped binaries have few symbols, so this is limited.
### Mixed source display

Use the -S option to interleave source code with disassembly when debug information is present.

- **Use case**: Inspect a problem reproduced with a debug build at source level.
- **What you get**: Correspondence between source lines and assembly.
- **Limitations**: Does not work on binaries with debug information removed.
## Installation and usage

### Ubuntu / Debian

It is included in the binutils package and usually installed together with gcc.

```
sudo apt update
sudo apt install binutils
```

### RHEL / CentOS / Fedora

Install binutils from the default repositories.

```
sudo dnf install binutils
```

### Version check

Check the installed version and compare it with the latest official version.

```
objdump --version | head -1
```

## Practical usage examples

### Check section list

Examine the section layout of an ELF file.

```
objdump -h ./app-server
```

### Disassembly (example)

Disassemble around the main symbol. The output is an example.

```
objdump -d --disassemble=main ./app-server
```

### Check dynamic symbols

View the list of dynamically linked functions.

```
objdump -T ./app-server | head
```

## Advantages and limitations

### Advantages

- It is included by default in almost all Linux development and build environments, so there is no installation burden.
- It provides sufficient functionality for file-level static analysis from the command line.
- As a standard binutils component alongside GDB and readelf, it has abundant documentation and resources.
- It is freely used and redistributed under the GPL license.
### Considerations before use

- It has no GUI or decompilation capabilities, so understanding at the human-code level requires additional tools.
- Large binaries produce massive output, requiring filtering skills.
- Symbol-based disassembly is limited for stripped files.
- PE and Mach-O support can be limited compared to ELF.
## Comparison with similar programs

| Program | Characteristics | Suitable when |
| --- | --- | --- |
| readelf | ELF-specific, provides more detailed header and dynamic section information. | When you need to inspect ELF metadata precisely. |
| gdb | Supports both runtime debugging and static disassembly. | When you need to see runtime variables and the stack. |
| radare2 | A multi-architecture reversing framework with strong GUI and scripting capabilities. | When deeply analyzing binaries across various architectures. |

## Official resources and further learning

- [Official homepage](https://www.gnu.org/software/binutils/) — https://www.gnu.org/software/binutils/
- [Official documentation / knowledge base](https://sourceware.org/binutils/docs/) — https://sourceware.org/binutils/docs/
- [Official download](https://ftp.gnu.org/gnu/binutils/) — https://ftp.gnu.org/gnu/binutils/
- [Release notes](https://sourceware.org/pipermail/binutils/) — https://sourceware.org/pipermail/binutils/
- [Source / development resources](https://sourceware.org/git/binutils-gdb.git) — https://sourceware.org/git/binutils-gdb.git
Version and supported environment information is based on the official site as of 2026-10-18. Installation commands may vary depending on the distribution and version you use, so please also check the official installation documentation.

## Actual execution screen

This is a synthetic example reconstructing the objdump section header output (-h) in a server-style view. The screen is a synthetic example and is not an actual execution result.

![objdump -h ELF section list output: a terminal showing sections such as .interp and .note](https://games.aidebatehub.com/assets/objdump-demo.png)

Actual production server

---
Source (HTML): https://games.aidebatehub.com/programs/apps/security/objdump.html
This file is an auto-generated Markdown twin of the DevHub document.