44 Lifetime and storage duration

44.1 The standard’s four axes — storage duration, scope, linkage, storage class

Let us set the terms out formally here. The C standard defines four mutually independent properties for names and objects, and lumping them together guarantees confusion later (especially over static’s two faces).

The last line matters. static, extern, auto, register, typedef, and C11′s _Thread_local (C23′s thread_local) are words occupying one slot syntactically, and which of them you write fixes the three properties above. There is only one such slot per declaration, so static extern int x; is a syntax error.

44.1.1 Storage duration — four

The standard’s word is not dynamic but allocated storage duration. What is commonly called “dynamic allocation” is this, and this book follows the common usage while recording the standard term here.

44.1.2 Scope — four

The range in which a name is visible. The C standard divides it into four.

The third will look unfamiliar: it is the special case that a label is visible throughout the function wherever inside it it is written. The fourth fixes how far a name written only in a prototype, as in void f(int count);, lives — it disappears outside the parentheses, so a prototype’s parameter names are effectively comments.

The inner hides the outer. When the same name overlaps, the inner block’s wins.

int n = 1;                  /* file scope */
void f(void) {
    int n = 2;              /* block scope — hides the outer n */
    { int n = 3; use(n); }  /* here it is 3 */
    use(n);                 /* here it is 2 */
}

44.1.3 Linkage — three

It fixes whether the same name appearing in several places refers to one and the same object. It is the groundwork of chapter 54 (several files).

#idx("internal")  static int counter;        /* file scope: makes the linkage *internal* (the duration was static anyway) */

  void f(void) {
      static int calls;      /* block scope: makes the storage duration *static* (there is no linkage) */
  }

44.1.4 The seven storage-class specifiers — gathered in one place

The words that may fill this slot number seven in C23, and that is all of them. This is the place that gathers the list.

/* See what a storage-class specifier decides.
   Also the rule that one declaration takes only one of them - and its
   single exception. */
#include <stdio.h>

static int file_only = 1;          /* internal linkage - visible only in this file */
extern int shared;                 /* a promise only - the real thing is below */
int        shared = 2;             /* the definition */
thread_local int per_thread = 3;   /* one per thread */

static int bump(void)
{
    static int calls = 0;          /* static storage duration - survives between calls */
    return ++calls;
}

int main(void)
{
    auto int local = 4;            /* the pre-C23 meaning: automatic storage duration (the default) */
    register int hot = 5;          /* the old request. its address cannot be taken */
    constexpr int fixed = 6;       /* C23 - a compile-time constant */
    static_assert(fixed == 6, "constexpr is a constant expression");

    printf("file_only=%d shared=%d per_thread=%d local=%d hot=%d fixed=%d\n",
           file_only, shared, per_thread, local, hot, fixed);
    /* Calling it several times in one statement leaves the order unspecified
       (chapter 34), so call it once per line. */
    int b1 = bump(), b2 = bump(), b3 = bump();
    printf("bump() three times: %d %d %d   <- a static local survives\n", b1, b2, b3);

    /* static extern int bad;   <- error: multiple storage classes            */
    /* int *p = &hot;           <- error: address of register variable        */
    /* auto constexpr int c=1;  <- error: 'auto' used with 'constexpr'        */
    static thread_local int ok = 7;   /* the one combination allowed as an exception */
    printf("static thread_local ok=%d\n", ok);
    return 0;
}

file_only=1 shared=2 per_thread=3 local=4 hot=5 fixed=6
bump() three times: 1 2 3   <- a static local survives
static thread_local ok=7

The example shows all seven at once. The four starred rows are worth unfolding.

The two faces of static are what the previous section showed. The same word fixes a lifetime in one context and a linkage in another — C’s most famous reuse of a word.

auto is a word whose meaning changed. Originally it stated “automatic storage duration”, which nobody wrote because it was the default. C23 gave the empty slot to type inference — write auto x = 1 + 2; and the type comes from the initialiser. The old use, auto int local;, still compiles (the example writes it that way), but there is no reason to put it in new code.

register is almost dead, but not entirely. The request “keep this in a register if you can” has no effect on today’s optimisers — register allocation is something the compiler does far better (chapter 11). ★ But one rule survived: the address of an object declared register cannot be taken. The example’s comment marks the spot; compile it and it says address of register variable 'hot' requested. Some people use this deliberately, to pin down for the compiler and the reader that “this variable’s address never escapes”.

typedef is here because of the grammar. It occupies the same slot as a storage class but makes no object. So read it like this — “in the place where this declaration would create a variable, a type name is created instead” (chapter 60).

44.1.5 The slot holds one — and its exception

★ A declaration may take only one storage-class specifier. Measured, it says this:

static extern int x;      -> error: multiple storage classes in declaration specifiers
typedef static int T;     -> error: multiple storage classes in declaration specifiers
auto constexpr int k = 1; -> error: 'auto' used with 'constexpr'

The exception is thread_local, alone. It may be written together with static or extern, because thread storage duration and linkage are separate axes and both sometimes need fixing. The example’s static thread_local int ok = 7; is that case.

44.2 Two lifetimes

A local variable in C has, by default, automatic storage duration — born on entering a block, dead on leaving. That parameters and local variables are born anew on each function call was the ground on which chapter 33′s recursion stood.

Attach static and it becomes static storage duration — born once before the program starts and living until it ends (initialised exactly once too). The demonstration contrasts the two.

#include <stdio.h>

int next_ticket(void)
{
    static int issued = 0;      /* static lifetime: it survives between calls */
    issued += 1;
    return issued;
}

int fresh_count(void)
{
    int n = 0;                  /* automatic lifetime: born anew on every call */
    n += 1;
    return n;
}

int main(void)
{
    /* calls with side effects get their own statements — chapter 29's rule as it is */
    int t1 = next_ticket();
    int t2 = next_ticket();
    int t3 = next_ticket();
    printf("next_ticket: %d %d %d\n", t1, t2, t3);

    int f1 = fresh_count();
    int f2 = fresh_count();
    int f3 = fresh_count();
    printf("fresh_count: %d %d %d\n", f1, f2, f3);
    return 0;
}

next_ticket: 1 2 3
fresh_count: 1 1 1

next_ticket’s issued keeps its value between calls and grows 1, 2, 3, while fresh_count’s n is born anew on each call and is always 1. Both are “variables inside a function” and yet their lifetimes differ. (Note in addition that the demonstration split the calls into separate statements — exactly chapter 33′s rule that piling side-effecting calls into one expression leaves the evaluation order unspecified.)

44.3 The layout of memory — the regions with our own eyes

At this point let us see in one picture how a program’s memory is actually laid out. Below are addresses printed directly on this book’s verification machine.

/* Where a program's memory really sits, confirmed by addresses.
   (The concrete values differ by machine, operating system and run. What to
    look at is the *order of the regions*.) */
#include <stdio.h>
#include <stdlib.h>

const char  ro_text[]  = "read-only";    /* a constant — usually the read-only region */
int         initialized = 7;             /* a global with a value — data */
int         zeroed;                      /* a global without one — bss   */

static void deeper(int depth, char *outer)
{
    char here;                            /* a local variable of this frame */
    if (depth == 0) {
        printf("  local variable one frame deeper : %p\n", (void *)&here);
        printf("  difference from the outer frame : %+ld bytes\n",
               (long)(&here - outer));
        printf("  => the stack grows toward %s addresses\n",
               (&here < outer) ? "lower" : "higher");
        return;
    }
    deeper(depth - 1, outer);
}

int main(void)
{
    static int  static_local;             /* local, but with static storage duration */
    int         automatic = 1;            /* automatic storage duration — the stack */
    void       *heap1 = malloc(64);
    void       *heap2 = malloc(64);

    printf("code (the function main)   : %p\n", (void *)(void (*)(void))main);
    printf("read-only string           : %p\n", (void *)ro_text);
    printf("global (with a value, data): %p\n", (void *)&initialized);
    printf("global (without one, bss)  : %p\n", (void *)&zeroed);
    printf("static inside a function   : %p\n", (void *)&static_local);
    printf("heap (malloc 1)            : %p\n", heap1);
    printf("heap (malloc 2)            : %p\n", heap2);
    printf("stack (a local variable)   : %p\n", (void *)&automatic);
    printf("\ngap between the two heap blocks : %+ld bytes\n", (long)((char *)heap2 - (char *)heap1));
    printf("distance from stack to heap     : about %.1f TiB (a 64-bit address space is this wide)\n\n",
           ((double)((char *)&automatic - (char *)heap1)) / (1024.0 * 1024.0 * 1024.0 * 1024.0));

    char anchor;                          /* the reference point for measuring the stack's direction */
    deeper(1, &anchor);

    free(heap1);
    free(heap2);
    return 0;
}

code (the function main)   : 0x55c08e4151f1
read-only string           : 0x55c08e416008
global (with a value, data): 0x55c08e418028
global (without one, bss)  : 0x55c08e418030
static inside a function   : 0x55c08e418034
heap (malloc 1)            : 0x55c0b66e62a0
heap (malloc 2)            : 0x55c0b66e62f0
stack (a local variable)   : 0x7ffe8ab42aec

gap between the two heap blocks : +80 bytes
distance from stack to heap     : about 42.2 TiB (a 64-bit address space is this wide)

  local variable one frame deeper : 0x7ffe8ab42a9f
  difference from the outer frame : -76 bytes
  => the stack grows toward lower addresses

The way to read it is the order, not the values. From low addresses they line up like this.

The example confirmed three things. data and bss sit side by side, the heap grows upward above them, and the stack grows downward from a far distant high address (the example’s last three lines stack one more frame and measure that direction).

44.4 The stack — the ledger of calls

The place where automatic variables live has a name — the stack. Each time a function is called, a bundle of slots for that call (a stack frame) is laid on top, and when the function ends it is lifted off whole. A frame contains, along with local variables and parameters, the address to return to (the return address) — the identity of the “return ledger” whose name was brushed past in chapter 43.

With the picture in place two things are explained at once. First, why chapter 33′s recursion piles up in layers — because one frame is laid on per call. And recurse too deeply and the stack space runs out and the program collapses (stack overflow — the representative symptom of infinite recursion). Second, why chapter 43′s boundary-violation attack is so dangerous — overflow an array on the stack and you can overwrite the return address of that same frame, whereupon the function, on finishing, “returns” to a place the attacker chose. One array’s boundary is connected to control of the program.

Two places in the layout of memory — the stack (automatic) and the static region — are learned. The remaining place is this part’s last: memory whose size is settled at run time and which stays alive as long as you wish — chapter 45′s dynamic memory.