Is it allowed for a compiler to optimize away a local volatile variable?

by

No. Access to volatile objects is considered observable behavior, exactly as I/O, with no particular distinction between locals and globals.

The least requirements on a conforming implementation are:

  • Access to volatile objects are evaluated strictly according to the rules of the abstract machine.

[…]

These collectively are referred to as the observable behavior of the program.

N3690, [intro.execution], ¶8

How exactly this is observable is outside the scope of the standard, and falls straightly into implementation-specific territory, exactly as I/O and access to global volatile objects. volatile means “you think you know everything going on here, but it’s not like that; trust me and do this stuff without being too smart, because I’m in your program doing my secret stuff with your bytes”. This is actually explained at [dcl.type.cv] ¶7:

[ Note: volatile is a hint to the implementation to avoid aggressive optimization involving the object
because the value of the object might be changed by means undetectable by an implementation. Furthermore,
for some implementations, volatile might indicate that special hardware instructions are required to access
the object. See 1.9 for detailed semantics. In general, the semantics of volatile are intended to be the same in C++ as they are in C. — end note ]

More Related Contents:

  1. reinterpret_cast creating a trivially default-constructible object
  2. Is stateful metaprogramming ill-formed (yet)?
  3. What made i = i++ + 1; legal in C++17?
  4. Is a pointer with the right address and type still always a valid pointer since C++17?
  5. How is P0522R0 breaking code?
  6. structured bindings: when something looks like a reference and behaves similarly to a reference, but it’s not a reference
  7. std::ignore with structured bindings?
  8. Deducing first template argument with other template parameters defaulted
  9. Does the behavior of guaranteed copy elision depend on existence of user-defined copy constructor?
  10. Self-initialization of a static constexpr variable, is it well-formed?
  11. Can std::launder be used to convert an object pointer to its enclosing array pointer?
  12. Static member access in constant expressions
  13. Pointer interconvertibility vs having the same address
  14. Does accessing a declared non-volatile object through a volatile reference/pointer confer volatile rules upon said accesses?
  15. Why doesn’t an if constexpr make this core constant expression error disappear?
  16. Will I be able to declare a constexpr lambda inside a template parameter?
  17. What changes to C++ made copy initialization work for class with explicit constructor?
  18. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?
  19. Directly write into char* buffer of std::string
  20. Order of evaluation of arguments using std::cout
  21. Do distinct functions have distinct addresses?
  22. Is adding to a “char *” pointer UB, when it doesn’t actually point to a char array?
  23. “If constexpr” in C++17 does not work in a non-templated function
  24. Will consteval functions allow template parameters dependent on function arguments?
  25. Is the Empty Base Class Optimization now a mandatory optimization (at least for standard-layout classes)?
  26. Classes with both template and non-template conversion operators in the condition of switch statement
  27. Why isn’t RVO applied to base class subobject initialization?
  28. Is it a strict aliasing violation to alias a struct as its first member?
  29. What is the modern, correct way to do type punning in C++?
  30. Overload resolution with ref-qualifiers

Leave a Comment