Re: Address and bit mask

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

On 30.08.11 11:14, milouz wrote:

> Hum... well... I still do not know how to do some simple arithmetic
> with address.

As has been said, addresses are addresses of something.
The "something" which your pointers will refer to can
be addressed, aligned, and laid out very specifically
using the attribute functions and packages mentioned. OTOH...

> So, let me give you an example in C :
>
>   p = (char*) (((unsigned long)p + ALIGN_MASK) & ~ALIGN_MASK);

The only address arithmetic in there is ... I'm not sure,
have you got the parentheses right?

Assuming this from the Linux kernel source:

/*
 * Round up the ptr to an 8-byte boundary.
 */
#define ALIGN_MASK 7
static inline void *align_ptr(void *ptr)
{
        return (void *) (((size_t) (ptr + ALIGN_MASK)) & ~ALIGN_MASK);
}

(Which, incidentally, gives
test.c:8:34: warning: pointer of type �void *� used in arithmetic)

Assuming your program cannot control alignment using 'Alignment,
layout specifications, and offsets etc, as Ludovic has shown.
Cannot perform arithmetic on addresses using this function
from System.Storage_Elements:

        function "+"(Left : Address; Right : Storage_Offset)
          return Address;

Also assuming that you want exactly C's pointer arithmetic,
copying C's rules, relying on void* casts, and not use Ada
facilities for a reason. (Side note: C's pointer arithmetic
and alignment are not defining what's in the hardware, storage
elements are not defined in C WRT size etc; C refers to hardware
and compiler for further reading.  That's somewhat less so in
Ada.)

Then Interfaces.C.Pointers is your friend, for helping with writing
C in Ada, including the necessary C pointer arithmetic functions,
such as

	function "+" (Left : in Pointer;  Right : in ptrdiff_t)
	  return Pointer;

It is also worthwhile searching the compiler docs that state which
type corresponds with C's void* on your platform.  (System.Address
in case of many GNATs.)

If the platform allows direct interpretation of the bits of
a pointer as an Unsigned_N (no composite pointers, for example),
then after Unchecked_Conversion, the bit operations used in
align_ptr above would be those of Unsigned_N (with suitable N),
named "and" and "not".