Path: utzoo!attcan!uunet!husc6!mailrus!ames!pasteur!ucbvax!decwrl!hplabs!hpda!hp-sde!hpfcdc!cunniff From: cunniff@hpfcdc.HP.COM (Ross Cunniff) Newsgroups: comp.lang.c Subject: Re: volatile: a summary Message-ID: <5080025@hpfcdc.HP.COM> Date: 10 Jun 88 18:41:42 GMT References: <11837@mimsy.UUCP> Organization: HP Ft. Collins, Co. Lines: 67 In article <11884@mimsy.UUCP>, chris@mimsy.UUCP (Chris Torek) writes: > ...whenever a > programmer can discover that *(int *)0xf0 is not volatile, but *(int *) > 0xff4 is, by reading a manual, a hypothetical perfect compiler can do > the same by reading `(the electronic version of) the manual'.... > ...The compiler's electronic > version of the manual might even read > > volatile 0xff0..0xf9f > > In this case, even though the word `volatile' appears *somewhere*, it > is nowhere in the C source, and hence the language proper has no > volatile keyword. > > For those who will claim that this is mere trickery, again, you have > not thought hard enough about the issue. Instead of `volatile > 0xff0..0xf9f' the manual might instead say `ram 0x0..0xeff; ram > 0x4000..0xbfffffff'. Instead of saying what *is* volatile, this says > what *cannot* *be* volatile. And if the electronic manual does not > exist, or if my hypothetical perfect compiler does not exist, as it > does not, or even if it *cannot* exist, what then? Is the volatile > keyword necessary? No. This is all fine and dandy for those volatile hardware addresses which a C program may access. It doesn't do diddly-squat for the following type of program (this example should but doesn't use volatile): /* foo.c */ extern int *p; foo( x ) { int i; *p = x; if( *p == x ) { /* With an optimizing compiler, this part of the */ /* 'if' is likely ALWAYS to be executed, regardless */ /* of whethter other processes are playing with */ /* shared memory */ printf( "Nobody else is plaing with shared memory\n" ); } else { printf( "Wow! somebody else is out there...\n" ); } } /* main.c */ int *p; char *shm_get(); main() { p = (int *)shm_get( 3000, "foobar" ); foo( getpid() ); } Note that there is *NO WAY* for the compiler *OR* the linker to know where the shm_get thingie is going to attach the shared memory segment. Oh, sure, you could have a dictionary that says that 'volatile shm_get', but if you're going to go that far, you might as well just add volatile to the standard (oh, we're already doing that?). Ross Cunniff Hewlett-Packard HP-UX DCE lab ...{ucbvax,hplabs}!hpda!cunniff cunniff%hpda@hplabs.ARPA