21.2 volatile Variables and Fields

The GNU C compiler often performs optimizations that eliminate the need to write or read a variable. For instance,

int foo;
foo = 1;
foo++;

might simply store the value 2 into foo, without ever storing 1. These optimizations can also apply to structure fields in some cases.

If the memory containing foo is shared with another program, or if it is examined asynchronously by hardware, such optimizations could confuse the communication. Using volatile is one way to prevent them.

Writing volatile with the type in a variable or field declaration says that the value may be examined or changed for reasons outside the control of the program at any moment. Therefore, the program must execute in a careful way to assure correct interaction with those accesses, whenever they may occur.

The simplest use looks like this:

volatile int lock;

This directs the compiler not to do certain common optimizations on use of the variable lock. All the reads and writes for a volatile variable or field are really done, and done in the order specified by the source code. Thus, this code:

lock = 1;
list = list->next;
if (lock)
  lock_broken (&lock);
lock = 0;

really stores the value 1 in lock, even though there is no sign it is really used, and the if statement reads and checks the value of lock, rather than assuming it is still 1.

A limited amount of optimization can be done, in principle, on volatile variables and fields: multiple references between two sequence points (see Sequence Points) can be simplified together.

Use of volatile does not eliminate the flexibility in ordering the computation of the operands of most operators. For instance, in lock + foo (), the order of accessing lock and calling foo is not specified, so they may be done in either order; the fact that lock is volatile has no effect on that.