Re: volatile vs aliased

[Ludovic Brenta <ludovic@ludovic-brenta.org>]

"REH" <spamjunk@stny.rr.com> writes:
> I'm converting some code written for Gnat to compile with Apex.  The
> software has bindings to C functions (OS calls).  Some of these take
> System.Address as parameters.  Apex complains about the variables used
> in these calls (via 'Address) because they not volatile or aliased (or
> imported, exported, etc.).  My question is: which should I use?  Is
> there any difference whether a variable is volatile or aliased?
>
> I am assuming the compiler is concerned about the variable possibly
> being changed in the call (which, of course, is true).  Is there a way
> to satisfy the compiler without stopping optimizations of the variable
> after the call, or do I need to use a second variable to do this?

I like this warning given by Apex; I think it would be nice if GNAT
would also warn in this situation.

pragma Volatile (Variable) says the compiler must not optimise away
any reads or writes to that variable, and that it may not add extra
reads or writes beyond those you explicitly request in your program
text.  You want to use that for hardware registers, where a "read"
operation may have a side effect such as changing the device's state.

Whenever you access a variable through an address value, the variable
is aliased, so you should say that explicitly.  Otherwise, the
compiler may be tempted to place the variable in a processor register,
which has no address.

In addition, pragma Import (Ada, Variable) says that the compiler may
not insert default initialisations for that variable, or assume
anything about the value of the variable, before you write to it.  But
the compiler may do optimisations, because it is allowed to assume
that no side effects occur when you read from or write to the variable
(that is, side effects not explicitly requested from the program
text).  In your situation, it seems that you want something like this
(which, incidentally, I use very often):

type T is ...;

procedure Read_Variable (At_Address : in  System.Address;
                         Into       : out T) is
   V : aliased T;
   -- suppress default initialisation, I know what I'm doing.
   pragma Import (Ada, V);
   for V'Address use At_Address;
begin
   -- perform my own explicit validation of the variable, perhaps
   -- using 'Valid; then, copy into Into:
   Into := V;
end Read_Variable;

-- 
Ludovic Brenta.