Re: Where are returned values stored?

["Warren W. Gay VE3WWG" <ve3wwg@cogeco.ca>]

Marius Amado Alves wrote:
>> It has a declarative part in the middle of the code, in which a
>>variable (Result)  is declared.  The stuff in that variable is
>>returned.
> 
> This is a common idiom. In many languages. Don't think in machine terms,
> think in language terms. *Values* are being passed around, not objects. You
> are already thinking value (stuff in that variable), so that's good. When
> you call the function, you provide a place, usually a variable, to hold the
> value.
> 
>    Object := Function_Call;
> 
> So no worries. The value might have travelled to Japan and back, but that's
> the machine business, not the programmer's. Now it's held in your Object,
> and that's all you need. This from a function user standpoint. From a
> function writer standpoint, well, think value again. When you write
> 
>    return Result;
> 
> you're passing the value. Under the language contract, the user we'll catch
> it. (In Ada he has to catch it, in C he can drop it on the spot.)

If you're worried about the inefficiency of copying data around,
then I would suggest that the above advice is good. Leave that
up to the compiler/machine team.

If you really must know more than that, then you'll need to look
at the assembler output, but maybe the following explanation
might save you from bothering/worrying about it:

Conceptually, there is _no_ reason a compiler _must_ copy a
return value. Consider a function like:

function Foo return String is
   I : Integer := 23;
   S : String(1..3) := "Bar";
   X : Natural := 0;
begin
   ...
   return S;
end;

To return S, all the compiler needs to do is to extend the
caller's stack frame to claim all the storage up to and
including S (I and S assuming sequential assignment), at
the point when Foo returns (return effectively does
reclaim the storage used for X however).

Then the calling code can reference S as if it were a
local variable.  The space used for I is
wasted at this point, but temporarily, who cares?

Once the compiler knows that the caller's use of the returned
value S is no longer required, the stack frame can be shrunk
back to the original size that it had prior to calling Foo.

Is this done? Is it done by GNAT? I have no idea, but I
suspect that this is done in some places, some of the time,
by some compilers. Perhaps, someone in this group
can confirm/debunk this idea.
-- 
Warren W. Gay VE3WWG
http://home.cogeco.ca/~ve3wwg