# longjmp

> C++ Atlas: `cppatlas.com/w/c/program/longjmp` | Source: https://en.cppreference.com/w/c/program/longjmp | Domain: Program support utilities | Standards: C99, C11, C23

Loads the execution context env saved by a previous call to setjmp. This function does not return. Control is transferred to the call site of the macro setjmp that set up env.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <setjmp.h>
void longjmp( jmp_buf env, int status ); // (until C11)
_Noreturn void longjmp( jmp_buf env, int status ); // (since C11) (until C23)
[[noreturn]] void longjmp( jmp_buf env, int status ); // (since C23)
```

Loads the execution context `env` saved by a previous call to `setjmp`. This function does not return. Control is transferred to the call site of the macro `setjmp` that set up `env`. That `setjmp` then returns the value, passed as the `status`.

If the function that called `setjmp` has exited (whether by return or by a different `longjmp` higher up the stack), the behavior is undefined. In other words, only long jumps up the call stack are allowed.

Jumping across threads (if the function that called `setjmp` was executed by another thread) is also undefined behavior. (since C11)

(since C99):

If when `setjmp` was called, a VLA or another variably-modified type variable was in scope and control left that scope, `longjmp` to that `setjmp` invokes undefined behavior even if control remained within the function.

On the way up the stack, `longjmp` does not deallocate any VLAs, memory leaks may occur if their lifetimes are terminated in this way:

```c
void g(int n)
{
    int a[n]; // a may remain allocated
    h(n); // does not return
}
void h(int n)
{
    int b[n]; // b may remain allocated
    longjmp(buf, 2); // might cause a memory leak for h's b and g's a
}
```

### Parameters

- `env` - variable referring to the execution state of the program saved by `setjmp`
- `status` - the value to return from `setjmp`. If it is equal to `​0​`, `1` is used instead

### Return value

(none)

### Notes

`longjmp` is intended for handling unexpected error conditions where the function cannot return meaningfully. This is similar to exception handling in other programming languages.

### Example

```c
#include <stdio.h>
#include <setjmp.h>
#include <stdnoreturn.h>

jmp_buf my_jump_buffer;

noreturn void foo(int status)
{
    printf("foo(%d) called\n", status);
    longjmp(my_jump_buffer, status + 1); // will return status+1 out of setjmp
}

int main(void)
{
    volatile int count = 0; // modified local vars in setjmp scope must be volatile
    if (setjmp(my_jump_buffer) != 5) // compare against constant in an if
        foo(++count);
}
```

Output:

```text
foo(1) called
foo(2) called
foo(3) called
foo(4) called
```

### References

- C17 standard (ISO/IEC 9899:2018):

  - 7.13.2.1 The longjmp macro (p: 191-192)

- C11 standard (ISO/IEC 9899:2011):

  - 7.13.2.1 The longjmp macro (p: 263-264)

- C99 standard (ISO/IEC 9899:1999):

  - 7.13.2.1 The longjmp macro (p: 244-245)

- C89/C90 standard (ISO/IEC 9899:1990):

  - 4.6.2.1 The longjmp function

### See also

- [`setjmp`](https://en.cppreference.com/w/c/program/setjmp): saves the context (function macro)
- [C++ documentation for `longjmp`](https://en.cppreference.com/w/cpp/utility/program/longjmp)

---
Attribution: content from https://en.cppreference.com/w/c/program/longjmp (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.