Do while(1) and for(;;) Really Differ? A Deep Dive into C Infinite Loops

Introduction

When readers ask whether while(1) and for(;;) are truly different infinite loops, the answer lies in their syntax, semantics, and the compiled output. By writing minimal programs with each construct, compiling them with gcc, and inspecting the resulting assembly, we can see the real differences—or lack thereof.

Syntax of the Two Constructs

while syntax

while ( expression )
{
    statement;
}

In an infinite loop the expression is the constant 1, which is always true.

for syntax

for ( expr1 ; expr2 ; expr3 )
{
    statement;
}

When all three expressions are omitted (i.e., for(;;)), the loop has no initialization, condition, or iteration step, and the compiler treats it as an unconditional jump.

Execution Semantics

For while(1) the runtime evaluates the constant expression on each iteration; the constant 1 is compared to zero, which is a trivial true check. For for(;;) the three empty expressions are compiled away, and the loop becomes a direct infinite jump.

Experimental Verification

Two source files were created:

// while.c
int main(int argc, char const *argv[])
{
    while(1) {}
    return 0;
}

// for.c
int main(int argc, char const *argv[])
{
    for(;;) {}
    return 0;
}

Both files were compiled to assembly with the commands:

gcc -S -o while.s while.c
gcc -S -o for.s for.c

The generated assembly for each file is shown below (identical except for the source‑file comment):

; filename: while.s
.file "while.c"
.text
.globl main
.type main, @function
main:
.LFB0:
    .cfi_startproc
    pushq %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq %rsp, %rbp
    .cfi_def_cfa_register 6
    jmp .L2
.L2:
    jmp .L2
    .cfi_endproc
    .size main, .-main
    .ident "GCC: (GNU) 9.3.0"
    .section .note.GNU-stack,"",@progbits

; filename: for.s
.file "for.c"
.text
.globl main
.type main, @function
main:
.LFB0:
    .cfi_startproc
    pushq %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq %rsp, %rbp
    .cfi_def_cfa_register 6
    jmp .L2
.L2:
    jmp .L2
    .cfi_endproc
    .size main, .-main
    .ident "GCC: (GNU) 9.3.0"
    .section .note.GNU-stack,"",@progbits

Both assemblies contain the same instructions; the only difference is the comment indicating the original source file.

Comparison and Findings

Both loops produce identical machine code for an infinite loop.

The extra constant‑evaluation in while(1) is optimized away by modern compilers, so no extra instructions are emitted.

File size of the generated object files is the same (aside from the source‑file name metadata).

Therefore, in practice there is no performance or size penalty for choosing one form over the other.

Conclusion

The perceived differences between while(1) and for(;;) are only syntactic. Modern compilers generate identical assembly for both, making them interchangeable for infinite loops. The choice can be based on coding style preferences rather than efficiency.

Illustrations