Noreturn Attribute

The [[noreturn]] attribute is a C++11 standard attribute specifier used to explicitly declare that a function will never return control flow to its immediate caller. It serves as a strict semantic guarantee to the compiler, altering how the compiler constructs the Control Flow Graph (CFG) and performs static analysis.

Syntax

The attribute is placed at the beginning of a function declaration, preceding the return type.

[[noreturn]] void terminateProcess();
[[noreturn]] int throwException(); 

Compiler Mechanics and Optimizations

When the compiler encounters a call to a function marked with [[noreturn]], it applies several mechanical adjustments to the compilation process:

1. Control Flow Graph Modification: The compiler marks the call site as a terminal node in the CFG. Any instructions sequentially following the call are flagged as unreachable.
2. Dead Code Elimination (DCE): Because the compiler knows control will not resume after the call, it strips out subsequent code, reducing binary size.
3. Stack Frame Optimization: The compiler may omit generating standard function epilogues (stack frame teardown) for the caller if the [[noreturn]] function is the last operation in a specific branch.
4. Static Analysis Suppression: It suppresses specific compiler warnings, most notably -Wreturn-type (“control reaches end of non-void function”), when a code path concludes with a [[noreturn]] call instead of a standard return statement.

Rules and Constraints

• Undefined Behavior (UB): If a function marked with [[noreturn]] violates its contract and actually returns to the caller (either by executing a return statement or reaching the closing brace }), the program exhibits Undefined Behavior.
• Return Types: The attribute does not require the function to have a void return type. A function can be declared to return int or any other type while still being [[noreturn]]. The return type is syntactically valid but practically ignored, as a value can never be passed back.
• Type System Isolation: [[noreturn]] is an attribute of the function’s declaration, not its type. It cannot be applied to function pointers, typedefs, or std::function signatures.

// VALID: Applied to declaration
[[noreturn]] void myFunc();

// INVALID: Cannot be applied to a function pointer type
void ([[noreturn]] *funcPtr)(); 

Valid Control Flow Mechanisms

To satisfy the compiler contract without triggering Undefined Behavior, a [[noreturn]] function must prevent control flow from returning to the caller via mechanisms such as:

• Throwing a C++ exception.
• Calling a process-terminating standard library function (e.g., std::abort, std::exit, std::terminate).
• Executing a non-local jump (e.g., std::longjmp).
• Entering an infinite loop that contains observable behavior (such as I/O operations, volatile memory accesses, or atomic/synchronization operations). Note: Under C++ forward progress guarantees, a trivial infinite loop (e.g., while(true) {}) without observable behavior is Undefined Behavior. The compiler is permitted to optimize the empty loop away, which would cause the function to reach its closing brace, thereby violating the [[noreturn]] contract.
• Executing a hardware-level trap or interrupt.

Master C++ with Deep Grasping Methodology!

Learn More