Re: Pragma Volatile

[dewar@gnat.com (Robert Dewar)]

Jeffrey Carter <jrcarter@acm.org> wrote in message news:<3BB64B13.81AFFB4D@acm.org>...
> If a register is an Integer, I would generally do
> 
> B : Integer;
> for B'Address use Register_Location;
> pragma Volatile (B);
> ...
> B := 0;
> B := 1;
> 
> But then, I don't have the C pointer fixation.


Be very careful about assumptions here. Suppose that
B is a 32-bit word, then there is nothing in the language
that says that

  B := 0;

has to generate a 32-bit store, it would be perfectly 
valid if the compiler generated a call to bcopy that
moved four bytes independently (inefficient, but not
incorrect).

I often find people making this kind of assumption, and
in the case of reads I saw one awful bug caused by this:

    
    type R is array (natural range <>) of Boolean;
    pragma Pack (R);
 
    Register : R (1 .. 32);
    for Register'Address use ...

    ...

    B := Register (3);

one compiler generated a word load, and extracted bit 3.
another compiler generated a byte load, and extracted bit 3 from the
byte.

Both code sequences are perfectly valid, and just as
efficient as one another. But the hardware had been
build to require word loads, and byte loads were don't
care and put the hardware into some obscure state.

The "fix" was to use a constrained base type (this was
the only use of the type anyway), and then both compilers
generated the 32-bit word load.

But of course the real bug is in the implicit assumption
in the code.

Yes, it is very neat to use the address clause for memory
mapped I/O devices, but it is definitely cheating in that
it is making unwarranted assumptions about the exact code
sequences generated. 

Technically such code is quite wrong, and should be replaced by
machine code inserts. But that is heavy
in practice. At the very least, document assumptions
like this ferociously, and isolate them in special
packages known to need looking at when porting. 

Robert Dewar
Ada Core Technologies