Re: How do I write directly to a memory address?

[Niklas Holsti <niklas.holsti@tidorum.invalid>]

Edward Fish wrote:
> On Feb 2, 10:52 pm, Syntax Issues <syntax.iss...@gmail.com> wrote:
>> I am planning to start learning lower-level programming with ada,
>> however, I was unable to find a solid tutorial on writing directly to
>> a memory address or interfacing with assembly. Does anyone know where
>> I can find a reference to some tutorials/information? Below is an
>> example of code I would like to be able to implement.
>>
> 
> As others have replied using the 'Address attribute on a constrained
> array of your video's cell-type {attribute-character pair}is the
> way to go.
> 
> But if you're using GNAT you may have noticed that it doesn't allow
> a straight "For Data'Address Use 16#000B_8000#;" because GNAT
> uses a private type and not a derivative of Universal_Integer.

That is correct, and it need not work on any compiler, because 
System.Address is an implementation-defined type. You should in effect 
consider it a private type.

> They recommend an implementation-dependent "to_Address" function,
> but that would make things non-portable.

As others have said earlier in this thread (before the language war) 
there is a standard conversion function in the package 
System.Storage_Elements: the function System.Storage_Elements.To_Address 
converts from the integer type System.Storage_Elements.Integer_Address 
to System.Address.

Perhaps this is the function that AdaCore meant? The function and its 
usage are standard. (The implementation of the function is of course 
implementation-dependent, as it should be.)

> After some thought and some fiddling here's a portable,
> insofar as I know, method to convert an integer literal
> or constant (or even variable) to an address containing
> that value.

Your method may work on some systems, but it is not portable, because it 
assumes that System.Address has the same size and the same internal 
representation as your integer type Address_Overlay.Address_Integer, 
which does not follow from the language standard.

The functions System.Storage_Elements.To_Address/To_Integer translate 
between the internal representations if they are different.

In your method, the overlay of an Address_Integer with a System.Address 
is the same as an Unchecked_Conversion (which would be a simpler way to 
implement the same, wrong, method).

By your method (or by Unchecked_Conversion) you can indeed make a 
System.Address that "contains" the given integer value, in the sense of 
containing the same bit pattern, but this bit pattern may not be the 
Address that you want.

> -- Address_Overlay.ads; Pragma pure may be added.
> With System;
> Package Address_Overlay is
> 
>    Type Address_Integer is Range 0..System.Memory_Size;
> 
> Private
> End Address_Overlay;
> 
> -----  Address_Overlay.This.ads; an instantiation of
> -----                             this provides the proper overlay
> Generic
>    Value : Address_Integer;
> Package Address_Overlay.This is
> 
>    Address : Constant System.Address;		-- Overlay Address with Value.
> 
> Private
>   Pragma Warnings (Off, "*overlay*");		-- Here we turn off the warning
>    For Address'Address Use Value'Address;	-- about a constant
> overlaying
>    Pragma Import( Ada, Address );		-- a variable; as that is our
>   Pragma Warnings (On, "*overlay*");		-- intention.
> End Address_Overlay.This;
> 
> -----------
> -- USAGE --
> -----------
>    Declare
>       Package An_Address( 16#000C_8000#  );
> 
>       Data : Integer;
>       For Data'Address Use An_Address.Address;
>    Begin
> 	Data:= 4;
>    End;

Here is an example of the use of System.Storage_Elements and its 
Integer_Address type and functions:

-- begin example

with System.Storage_Elements;
with Ada.Text_IO;

procedure ItoA is

    use Ada.Text_IO;
    use System;

    Value : aliased Float := 1.2345;
    -- A variable that we will modify through an overlay,
    -- just to show that we can do it.

    Value_Int_Address : constant Storage_Elements.Integer_Address :=
       Storage_Elements.To_Integer (Value'Address);
    -- The address of Value, as an integer.

    Value_Address : constant Address :=
       Storage_Elements.To_Address (Value_Int_Address);
    -- The address of Value, converted back from its integer form.

    Other_Value : Float;
    for Other_Value'Address use Value_Address;
    -- Other_Value now overlays Value.

begin

    Put_Line ("Value'Address as integer ="
       & Storage_Elements.Integer_Address'Image (Value_Int_Address));

    Put_Line ("Value originally =" & Float'Image (Value));

    Other_Value := 9.8765;

    Put_Line ("Value changed via Other_Value =" & Float'Image (Value));

end ItoA;

-- end example


So the OP should use System.Storage_Elements.To_Address (16#000B_8000#) 
to compute the address (if that number is indeed the right one to use).

It is conceivable that the implementations of System.Storage_Elements in 
two different Ada compilers for the same target system could have 
different interpretations of the Integer_Address type and thus different 
mappings from Integer_Address to System.Address. For example, if the 
target system is only addressable in units of 16-bit words, one compiler 
could choose to use "16-bit word" as the unit of Integer_Address and 
another compiler could choose to use "8-bit octet". For the latter 
compiler, only even values of Integer_Address would be valid. (There are 
some 16-bit processors where different C compilers differ in this way, 
in the addresses that they display in listings and symbol tables.)

For octet-addressable processors Integer_Address in any Ada compiler is 
almost sure to use octet units, so values of Integer_Address should be 
portable across compilers.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
       .      @       .