Can a C ++ compiler fix an unstable local Var that is not readable

Question

Let's say I have this code:

int f() { volatile int c; c=34; return abc(); } 

volatile int c is never read. But it is marked as volatile , can the compiler eliminate it at all? My testing in Visual C ++ 2010 shows conflicting results. In VC ++, if I turn on optimization (speed maximization), the above function contains a local variable c (looking at the generated list of assemblies). But instead of using the assignment operator, I also tried to initialize the variable with a built-in compiler function, such as memset () (and enable it using the built-in compiler functions), this variable was fixed.

 int f() { volatile int c; memset((void*)&c,34, 1); return abc(); } 

So, according to the C ++ standard, can the compiler eliminate the volatile int c? I think, probably, there is some inconsistent behavior in VC ++ related to how built-in functions optimize a mutable variable.

Answer 1

Thus, according to the C ++ standard, the compiler eliminates mutable int c?

No. volatile -qualified objects are used to read or write to hardware, and there are side effects of assigning a volatile object.

Therefore, in accordance with the restrictions on optimization, placed in the so-called “,”, in accordance with the implementations, it is not allowed to optimize c , the “As is” rule is officially introduced in paragraph 1.9 / 1 of the C ++ 11 standard:

The semantic descriptions in this International Standard define a parametrized non-deterministic abstract machine. There are no requirements for the structure of the corresponding implementations in this International Standard. In particular, they do not need to copy or emulate the structure of an abstract machine. Rather, appropriate implementations are needed to emulate (only) the observed behavior of an abstract machine, as explained below

And the concept of “observable behavior” is defined in paragraph 1.9 / 8:

Least requirements for the corresponding implementation:

- Access to unstable objects is evaluated strictly in accordance with the rules of an abstract machine .

- At the end of the program, all the data written to the files should be identical to one of the possible results that the program execution in accordance with abstract semantics.

- The dynamics of the input and output of interactive devices should take place in such a way as to induce the output is actually delivered before the program waits for input. What is an interactive device is determined by the implementation.

These aggregates are called observable program behavior . [...]

Since access to volatile objects must be evaluated strictly in accordance with the rules of an abstract machine, compilers are not allowed to optimize off c and the corresponding assignment operation.

Answer 2

memset((void*)&c,34, 1); has undefined behavior (§7.1.6.1 / 6). Thus, the compiler can get any result.

If an attempt is made to access an object defined using a type with variable qualification, using the value of glvalue with a type with unstable qualification, the program behavior is undefined.

Please do not use such roles, let alone C-style casts. When someone does not know what makes the correct C ++ for a certain situation, this is most likely a situation where no one should throw something.