volatile

Examples

The following is an example where the volatile keyword is required. If the volatile keyword is omitted, this example appears to still work. However, if the compiler inlines the code into a function that does not use the return value (old_table), then the inline assembly statement appears to be unnecessary, and could get optimized out. The volatile keyword lets the compiler know that the assembly has an effect other than providing the output value, so that this optimization does not happen.

void *swap_ttbr0(void *new_table) {
	void *old_table;
	__asm volatile (
		  "mrs %[old], TTBR0_EL1\n"
		  "msr TTBR0_EL1, %[new]\n"
		: [old] "=&r" (old_table)
		: [new] "r"   (new_table));
	return old_table;
}

The following example shows what happens when volatile is not used:

• Create foo.c containing the following code:

  #include <stdint.h>
  
  static uint32_t without_volatile(uint32_t CONTROL_new)
  {
      uint32_t CONTROL_old;
  
      __asm(
          "mrs %0, CONTROL\n"
          "msr CONTROL, %1\n"
          "isb\n"
          : "=&r" (CONTROL_old)
          : "r" (CONTROL_new)
      );
  
      return CONTROL_old;
  }
  
  
  static uint32_t with_volatile(uint32_t CONTROL_new)
  {
      uint32_t CONTROL_old;
  
      __asm volatile(
          "mrs %0, CONTROL\n"
          "msr CONTROL, %1\n"
          "isb\n"
          : "=&r" (CONTROL_old)
          : "r" (CONTROL_new)
      );
  
      return CONTROL_old;
  }
  
  void foo(void)
  {
      /* When without_volatile is inlined,
         the __asm statement is removed.
       */
      without_volatile(0);
  
      /* When write_with_volatile is inlined,
         the __asm statement is preserved.
       */
      with_volatile(1);
  }

• Build foo.c with:

  armclang --target=arm-arm-none-eabi -mcpu=cortex-m7 -O2 -std=c90 -c foo.c -o foo.o
  

  The compiler inlines the calls to the functions without_volatile() and with_volatile() into foo(). However, because foo() does not use the return value of without_volatile(), the compiler removes the call to without_volatile().

• Use the fromelf utility to see the result:

  fromelf --text -c foo.o
  ...
  ** Section #3 '.text.foo' (SHT_PROGBITS) [SHF_ALLOC + SHF_EXECINSTR]
      Size   : 16 bytes (alignment 8)
      Address: 0x00000000
  
      $t.0
      [Anonymous symbol #3]
      foo
          0x00000000:    2001        .       MOVS     r0,#1
          0x00000002:    f3ef8114    ....    MRS      r1,CONTROL
          0x00000006:    f3808814    ....    MSR      CONTROL,r0
          0x0000000a:    f3bf8f6f    ..o.    ISB
          0x0000000e:    4770        pG      BX       lr
  ...

For this example, the CONTROL register is never set to the value 0, and could result in unexpected runtime behavior.