What Is .rodata

Content on WhatAnswers is provided "as is" for informational purposes. While we strive for accuracy, we make no guarantees. Content is AI-assisted and should not be used as professional advice.

Last updated: April 11, 2026

Quick Answer: .rodata is a read-only data section in executable files that stores immutable constants, string literals, and static const variables. It is automatically created by the compiler and mapped to read-only memory pages by the operating system, preventing any modifications at runtime and providing automatic protection against memory corruption.

Key Facts

.rodata stands for 'read-only data' and is a standard section in ELF (Executable and Linkable Format) binary files used on Linux and Unix systems
The operating system maps .rodata to read-only memory pages with r-- permissions, enforcing hardware-level protection that triggers segmentation fault on write attempts
Attempting to write to the .rodata section causes an immediate SIGSEGV signal and process termination, preventing accidental or malicious data corruption
The compiler automatically places all string literals, const variables, and numeric constants into the .rodata section during the compilation process
.rodata sections typically comprise 5-15% of total binary size and enable compiler optimizations by guaranteeing constant values never change

Overview

.rodata is a dedicated memory section found in executable files and programs running on Linux and Unix-like systems. It stands for "read-only data" and contains all constant values and immutable data that a program needs during execution, including string literals, numeric constants, and data marked as constant by the programmer.

The .rodata section is created automatically by the compiler during the compilation process and becomes part of the final binary file. Unlike the .text section which contains executable code, or the .data and .bss sections which contain writable variables, .rodata is specifically designed to hold data that should never change while the program runs. The operating system enforces this by mapping the .rodata section to read-only memory pages, preventing any modifications at runtime.

How It Works

The creation and management of .rodata sections follows a well-defined process during compilation and execution:

Compiler Placement: During compilation, the C or C++ compiler analyzes the source code and automatically identifies all constant data. String literals like "Hello World", const variables, and enumeration values are placed directly into the .rodata section rather than the writable data section.
Binary Organization: In the compiled ELF (Executable and Linkable Format) binary file, the .rodata section is stored sequentially after the .text section. The section header contains metadata about its location in the file and its size, allowing loaders to position it correctly in memory.
Memory Mapping: When the program launches, the operating system's loader reads the ELF header and loads different sections into memory with appropriate permissions. The .rodata section is mapped with read-only permissions (r--), preventing write operations from the program or any other process.
Access Mechanism: When a program needs to access string literals or constants, the CPU simply reads the memory address where the data resides in the .rodata section. The memory protection hardware automatically enforces the read-only restriction at the CPU level.
Protection Enforcement: If a program attempts to write data to the .rodata section, the memory management unit (MMU) generates a segmentation fault (SIGSEGV signal), immediately terminating the process to prevent memory corruption.

Key Comparisons

Understanding how .rodata differs from other executable sections is crucial for understanding binary layout and memory protection:

Section	Contents	Permissions	Modifiable at Runtime
.text	Executable machine code and instructions	Read + Execute	No
.rodata	String literals, constants, const variables	Read Only	No
.data	Initialized global and static variables	Read + Write	Yes
.bss	Uninitialized global and static variables	Read + Write	Yes
.heap	Dynamically allocated memory	Read + Write	Yes

Why It Matters

The .rodata section provides several critical benefits for software security, reliability, and performance optimization:

Memory Protection: By separating immutable data into read-only sections, the operating system prevents accidental or malicious overwrites of critical constants. Buffer overflow attacks cannot corrupt data stored in .rodata since write operations are blocked at the hardware level.
Security Isolation: Read-only mapping of .rodata enables code signing and integrity verification features. The section can be verified once when the program loads and then protected from modification throughout execution, guaranteeing data integrity.
Compiler Optimization: Knowing that .rodata data never changes allows compilers to perform aggressive optimizations. The compiler can safely assume constant values remain constant, enabling dead code elimination, constant folding, and other performance enhancements.
Cache Efficiency: Since .rodata pages are never written to, the operating system can safely share them across multiple process instances running the same program. This reduces memory consumption and improves system-wide cache efficiency significantly.
Runtime Safety: Automatic protection against write attempts catches programming errors early. Developers receive immediate feedback through segmentation faults when their code accidentally tries to modify constant data.

The .rodata section exemplifies how modern operating systems and compilers work together to enforce data protection. By clearly separating read-only data from writable data, systems become more secure and efficient. This design principle has been standard in Unix-like systems for decades and remains a cornerstone of memory protection mechanisms in contemporary computing environments.