Re: Help with Copying Shared Memory to Local

[Stephen Leake <stephen.a.leake.1@gsfc.nasa.gov>]

"John R. Strohm" <strohm@airmail.net> writes:

> type x is record
>     csr: byte;
>     dr: byte;
> end record;
> for x use record at mod 2;
> for x'size use 16;
> 
> Or something of that nature.

This says that objects of type x are 16 bits in size, and located on
16 bit boundaries.

If we have the following code:

declare
   a : X;
   b : X;
begin
   a := b;
end;

The compiler is perfectly free to do two 8 bit copies. On an 8 bit
machine, that's what I'd expect!

Now consider this:

declare
   a : X;
   b : X;
   c : X;
   d : X;
begin
   a := b;
   c := d;
end;

The compiler is perfectly free to do one 32 bit copy. On a 32 bit
machine, that's what I'd hope for (not quite expect :).

Most compilers, most of the time, will do what you want. But it is
_not_ _guarranteed_ by the language.


Where I really got bit by this the first time was using a bit-mapped
rep spec to access the bits in a hardware register, which is the
natural way to do it in Ada. The compiler happily coded 8 bit accesses
to get to the bits it needed, and the hardware got thoroughly
confused. The only way to get it right was to use machine code to do a
16 bit read to normal RAM, then unchecked convert to the bit-mapped
rep spec. Then bit or byte access to the RAM copy was fine.

-- 
-- Stephe