Does accessing a declared non-volatile object through a volatile reference/pointer confer volatile rules upon said accesses?
volatile doesn’t mean the same thing in C & C++. The C++ standard makes accesses through volatile lvalues observable. [1] It says that it intends this to be the same as C behaviour. And that is the behaviour described in the C Rationale. Nevertheless the C Standard says that accesses to a volatile-declared objects are observable. (Note that accessing a volatile-declared object via a non-volatile lvalue is undefined.)
However. There is a defect report which essentially has committee agreement (although still open) that the Standard should say, and that the intent has always been, and that implementations have always reflected, that it is not the volatility of an object that matters (per the Standard) but of the volatility of (the lvalue of) an access (per the Rationale).
Defect Report Summary for C11 Version 1.10 Date: April 2016 DR 476 volatile semantics for lvalues 04/2016 Open
Of course, what is done about observable behaviour is implementation-dependent.
There really isn’t any ambiguity. It’s just that people can’t believe that the C Standard behaviour could be what it is, because that is not the historical usage pre-volatile (when address-literal lvalues were taken to be of volatile objects), as intended by the Rationale, as implemented by compilers before and since, as interpreted and described by the C++ Standard, as corrected in the DR. Similarly, the standard is clear in that it doesn’t say that non-volatile accesses are observable, so they’re not. (And “side effect” is a term used in defining the evaluation partial order.)
[1] Or at least hopefully it does now. From a comment from underscore_d:
For C++, see also P0612R0: NB comment CH 2: volatile, which was adopted this month to clean up some leftover talk about “volatile objects” in the C++ Standard, when really accesses through volatile glvalues are what it meant (as, presumably/hopefully, what C meant).