Volatile variable as initializer for non-volatile variable?

Hello all. Here is what i came across in some code the other day

int volatile some_magic;

int f() {
   int j = some_magic;

   // now do some nonsense calculus
   for(int i=0;i<10;i++)
     j += i;

   return j;
}

int main() {
   // do some loops and call f...
   for(int j = 0;j<100;j++) f();
   // ... (carefully crafted timings here)
}

Now, what are the conditions on the read of "some_magic"? It acts as an
initializer for "j", so it seems it somehow "depends" on its life. Can the
compiler, if it optimizes out "j" entirely, remove the read of "some_magic"?

It appears to me optimizing this out is not valid, because in the abstract
machine "some_magic" is actually read there. And optimizing out "j" can only
be done if it wouldn't disturb the observable behavior, but exactly that is
*not* the case. The observable behavior is different.

The compiler that was used (intel compiler, so it's the EDG frontend, i
suspect) optimized out the *entire code* but when "j" itself was made
volatile in addition it didn't optimize anymore. The reason that
"some_magic" was volatile is that it was some sort of intialization timer,
and the reason "j" wasn't volatile is because we wanted all the other code
to be as fast as possible, just the read from "some_magic" should be "real".

I'm a bit confused about this. What's the state of it in the Standard?
Thanks!

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]