> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C _Noreturn Function The `_Noreturn` keyword is a function specifier introduced in the C11 standard that explicitly instructs the compiler that a function will never return control flow to its caller. It acts as a strict semantic guarantee, altering compiler code generation and static analysis. ## Syntax and Declaration The specifier is applied to function declarations and definitions. It can appear anywhere within the declaration specifiers, though it is conventionally placed at the beginning of the signature. ```c theme={"dark"} /* Standard C11 keyword usage */ _Noreturn void halt_execution(void); /* Definition */ _Noreturn void halt_execution(void) { /* Implementation that must not return */ } ``` C11 also provides the `` header, which defines the macro `noreturn` as a convenience alias for `_Noreturn`. ```c theme={"dark"} #include noreturn void halt_execution(void); ``` ## C23 Deprecation and Modern Standard In the C23 standard, both the `_Noreturn` keyword and the `` header were officially deprecated. Modern C aligns with C++ by utilizing the standard attribute syntax `[[noreturn]]`. Developers targeting C23 or later should use the attribute instead of the keyword. ```c theme={"dark"} /* C23 standard attribute replacement */ [[noreturn]] void halt_execution(void); ``` ## Semantic Rules and Undefined Behavior * **Strict Non-Return Guarantee:** If a function declared with `_Noreturn` (or `[[noreturn]]`) executes a `return` statement, or if control flow reaches the closing brace (`}`) of the function body, the program invokes **undefined behavior (UB)**. * **Return Type:** While a non-returning function cannot yield a value to its caller, the C standard does not mandate that its return type be `void`. However, declaring it as `void` is the standard practice, as any specified return type is rendered meaningless. * **Type System Independence:** The `_Noreturn` specifier is a property of the function identifier, not part of the function's type signature. Consequently, it cannot be used in the declaration of a function pointer. ## Compiler Mechanics When the compiler processes a non-returning specifier, it modifies its standard behavior in three primary ways: 1. **Warning Suppression:** It suppresses static analysis warnings (e.g., "control reaches end of non-void function") within the calling function, as the compiler recognizes that execution will not proceed past the call site. 2. **Dead Code Elimination:** Any instructions sequentially following a call to a `_Noreturn` function are mathematically unreachable. The compiler marks this as dead code and strips it during the optimization phase. 3. **Stack and Call Site Optimization:** At the call site, the compiler may omit post-call cleanup instructions, such as restoring caller-saved registers or popping arguments pushed to the stack. Furthermore, within the definition of the `_Noreturn` function itself, the compiler can omit the standard function epilogue (stack frame teardown and the `ret` instruction), as the return address pushed to the call stack will never be consumed. ## Code Mechanics Example ```c theme={"dark"} #include #include /* Valid: Control flow is handed off to exit(), which is also non-returning. */ noreturn void valid_noreturn(void) { exit(1); } /* Invalid: Control flow reaches the end of the function body. This strictly results in Undefined Behavior. */ noreturn void invalid_noreturn(void) { int x = 5; x++; /* UB triggered here: implicit return to caller */ } ```

Tired of Poor C Skills? Fix That With Deep Grasping! Learn More