The difference between asm, asm volatile and clobbering memory

by

See the “Extended Asm” page in the GCC documentation.

You can prevent an asm instruction from being deleted by writing the keyword volatile after the asm. […] The volatile keyword indicates that the instruction has important side-effects. GCC will not delete a volatile asm if it is reachable.

and

An asm instruction without any output operands will be treated identically to a volatile asm instruction.

None of your examples have output operands specified, so the asm and asm volatile forms behave identically: they create a point in the code which may not be deleted (unless it is proved to be unreachable).

This is not quite the same as doing nothing. See this question for an example of a dummy asm which changes code generation – in that example, code that goes round a loop 1000 times gets vectorised into code which calculates 16 iterations of the loop at once; but the presence of an asm inside the loop inhibits the optimisation (the asm must be reached 1000 times).

The "memory" clobber makes GCC assume that any memory may be arbitrarily read or written by the asm block, so will prevent the compiler from reordering loads or stores across it:

This will cause GCC to not keep memory values cached in registers across the assembler instruction and not optimize stores or loads to that memory.

(That does not prevent a CPU from reordering loads and stores with respect to another CPU, though; you need real memory barrier instructions for that.)

More Related Contents:

  1. Assembly code fsqrt and fmul instructions
  2. How can I indicate that the memory *pointed* to by an inline ASM argument may be used?
  3. What is the difference between ‘asm’, ‘__asm’ and ‘__asm__’?
  4. Can I use Intel syntax of x86 assembly with GCC?
  5. When to use earlyclobber constraint in extended GCC inline assembly?
  6. Looping over arrays with inline assembly
  7. How to access C variable for inline assembly manipulation?
  8. Reading a register value into a C variable [duplicate]
  9. In GNU C inline asm, what are the size-override modifiers for xmm/ymm/zmm for a single operand?
  10. Why can’t local variable be used in GNU C basic inline asm statements?
  11. Inline assembly that clobbers the red zone
  12. Why we need Clobbered registers list in Inline Assembly?
  13. How to tell GCC to generate 16-bit code for real mode
  14. Using condition flags as GNU C inline asm outputs
  15. Why does GCC use multiplication by a strange number in implementing integer division?
  16. What is the meaning of “__attribute__((packed, aligned(4))) “
  17. Embedding binary blobs using gcc mingw
  18. Tell gcc to specifically unroll a loop
  19. Can I mix static and shared-object libraries when linking?
  20. Disable variable-length automatic arrays in gcc
  21. Create statically-linked binary that uses getaddrinfo?
  22. Yet Another MinGW “gcc: error: CreateProcess: No such file or directory”
  23. Pointer arithmetic when void has unknown size [closed]
  24. Referencing memory operands in .intel_syntax GNU C inline assembly
  25. Process Linkage Table and Global Offset Table
  26. GCC memory barrier __sync_synchronize vs asm volatile(“”: : :”memory”)
  27. Is there a way to use fopen_s() with GCC or at least create a #define about it?
  28. getrandom syscall in C not found
  29. argv: Sanitizing wildcards
  30. Query on -ffunction-section & -fdata-sections options of gcc

Leave a Comment