Consider the following statements

```
volatile int a = 7;
a;   // statement A
volatile int* b = &a;
*b;  // statement B
volatile int& c = a;
c;   // statement C

```

Now, I've been trying to find a point in the standard that tells me how a compiler is to behave when coming across these statements. All I could find is that A (and possibly C) gives me an lvalue, and so does B:

"§ 5.1.1.8 Primary expressions - General" says
----------------------------------------------

> 
> An identifier is an id-expression provided it has been suitably declared (Clause 7). [..]  
> 
>  [..] The result is the entity denoted by the identifier. The result is an
>  lvalue if the entity is a function, variable, or data member and a
>  prvalue otherwise.  
> 
>  [..]
> 
> 
> 

"§ 5.3.1 Unary operators" says
------------------------------

> 
> The unary \* operator performs indirection: the expression to which it is applied shall be a pointer to an object type, or a pointer to a function type and the result is an lvalue referring to the object or function to which the expression points.
> 
> 
> 

clang and gcc
-------------

I tried this with clang++ 3.2-11 and g++ 4.7.3, and the first produced three reads in C++11 mode and zero reads in C++03 mode (outputting three warnings) while g++ only produced the first two, explicitly warning me that the third would not be generated.

Question
--------

It is clear which type of value comes out of the expression, from the quoted line in the standard, but:  

*which of the statements (A,B,C) should produce a read from the volatile entity according to the C++ standard?*