Re: Semantics of Inline vs non-Inline

[Martin Krischik <krischik@users.sourceforge.net>]

skidmarks wrote:

> My compiler vendor says that the semantics of an inline/non-inline
> function can be different at the discretion of the compiler vendor. In
> particular, if at the point of use of an inline function the value of
> an argument (to the defined subprogram) is in a register, then it is
> acceptable to 'crash' because the address of the argument is not known
> (it's in a register).
> 
> My claim is that the semantics of of an inline and non-inline
> subprogram must be identical, and further, the application writer is
> both unaware and should be unaware of the code generated at the point
> of subprogram use.
> 
> Any idea which view is the correct one?
> 
> Art
> 
> ----------------------------------------------------------
> Example (in truncated pseudo-Ada):
> 
> package body x is
>    subtype Datum_Type is Natural;
>    package List is new abc.List_Manager( <size> );
>    function Push( Datum : Datum_Type ) return List.Cell_Ptr is
>       LM_Datum : List.Datum_Type;
>                  for LM_Datum'Address use Datum'Address;
>    begin -- Push
>      return List.Push(LM_Datum);
>    end Push;
>    pragma inline( Push );
> 
>    Cell : List.Cell_Ptr;
>    thing: Natural;
> begin -- x
>    Cell := Push(thing);
> end x;
> 
> This code does not work with    'pragma inline'.
> This code does     work without 'pragma inline'.
> 
> The vendor claims that the address of 'thing' is not known at the call
> (it may be in a register) and hence the inlined 'Push' does not have a
> valid input argument. My first statement is that the behavior for
> inline/non-inline should be the same, and that if it succeeds in one
> it should succeed in all. Is this a correct interpretation?

1st: only aliased data is guaranteed to have an 'Address. Even non inline
functions may use a register for certain data.

2nd: You must see 'Address as some form of Unchecked_Conversion - actually
the way you have used 'Address it is Unchecked_Unchecked_Conversion -
that's is the way a "reinterpret_cast <>" (if you know C++) is done in Ada.

With Regards

Martin

-- 
mailto://krischik@users.sourceforge.net
http://www.ada.krischik.com