Re: 64bit access to an array of 8bit values

["John R. Strohm" <strohm@airmail.net>]

The short answer is that you can't do what you want to do.

The Ada compiler is not required to allocate precisely one byte per array
element, and it probably didn't.  Instead, it will probably allocate one
"word" per array element, because word access is probably faster than byte
access.

Consider for a moment a processor like the TI 320C30 floating-point digital
signal processor.  It provides a 32-bit word, but it does NOT provide any
direct mechanism for addressing individual bytes within the word.  Location
N is 32 bits wide.  Location N+1 is the next 32 bits.

Consider for a moment the old Harris superminicomputers.  They used a 24-bit
word.  There is NOTHING the Ada compiler can do for you in that case,
because 32-bit and 64-bit access DOESN'T EXIST on that machine.

I was told in school many years ago that there was also a German standard
architecture, that specified a 48-bit word, of which three bits were
reserved for type tagging.  So you effectively had a 45-bit word that you
COULDN'T coerce to a different type without a lot of pain.

The first easy answer is that you model your memory as an array of Bit64,
and do the necessary bitpicking to extract the Bit8, Bit16, and Bit32 values
yourself.  If your machine doesn't support Bit64-like objects, then do it as
Bit32 and hack around the Bit64 access.

The other easy answer is that you model your memory as an array of Bit8, and
then you build up your Bit16, Bit32, and Bit64 accesses by doing multiple
Bit8 fetches and stores.

The UGLY answer is to create several procedures, MyPeek8, MyPoke8, MyPeek16,
MyPoke16, MyPeek32, ..., and then do assembly language interface to hide
your memory model under them.  If you are a real glutton for punishment,
look at the Ada machine code insertion capability.  Trust me: you DON'T want
to do this.  (I had to do a VMEbus interface for a DSP board this way
several years ago.  It worked, but it was NO FUN AT ALL.)

"Dave Poirier" <instinc@users.sf.net> wrote in message
news:3C823A1A.6030006@users.sf.net...
> I'm trying to modelize a small virtual machine, and I'm stuck on the
> memory model.  I'm defining the memory as an array of 8bit values, so
> that I am able to access every byte individually.  The problem comes
> when I try to access them with other data size, like 16/32/64bit.  GNAT
> simply refuses to do the pointer conversion (yeah, probably a bad habit).
>
> So, what would be a "clean" way to do it?  here's what I tried
>
> ------
> procedure test is
>    type Bit8 is mod 2**8;
>    type Bit64 is mod 2**64;
>    type Bit8Acc is access Bit8;
>    type Bit64Acc is access Bit64;
>
>    type RamRange is range 0 .. 4000;
>
>    Ram : array (RamRange) of aliased Bit8;
>    Value : Bit64Acc;
>
> begin
>    Value := Ram(0)'Access;
> end test;
> ------
>
> test.adb:14:18: expected type "Bit64Acc" defined at line 6
> test.adb:14:18: found type access to "bit8" defined at line 14
>
> and also..
> ------
> procedure test is
>    type Bit8 is mod 2**8;
>    type Bit64 is mod 2**64;
>    type Bit8Acc is access all Bit8;
>    type Bit64Acc is access all Bit64;
>
>    type RamRange is range 0 .. 4000;
>
>    Ram : array (RamRange) of aliased Bit8;
>    Value : Bit64Acc;
>
> begin
>    Value := Bit64Acc(Ram(0)'Access);
> end test;
> ------
>
> test.adb:14:12: argument of conversion cannot be access
> test.adb:14:12: use qualified expression instead
>
> I'm just a smooth skinned Ada95 newbie, so don't get too big weapons to
> send replies ;)
>
> Thanks for helping me learn :)
> EKS - Dave Poirier
>