[OT] Re: Question on mutability of argument lists

[Marco Maggi <marco.maggi-ipsu@poste.it>]

Niels Möller wrote:
> And somthing similar could be done even if the calling convention is the
> "natural" one, that the caller conses the arguments onto a list as they
> are evaluated, and passes that list to the implementation of the
> procedure. The function prologue in the callee would then extract
> arguments from that list, and only in the case that the function is
> defined with a rest argument, the prologue calls list-copy. And the
> compiler could even omit that list-copy in cases where it can infer that
> the list cannot be subject to any mutations.

Yes.  In some sense the  caller would use the arguments list
as "Scheme stack".

> (It's long time since I played with lisp/scheme implementation, but then
> I considered a calling convention where each procedure (and
> continuation) would have two entry points, one with a single argument
> passed in a register, and a second entry point where a pointer to an
> argument list is passed in that register. The first entry point would be
> used in the common case that there's a single argument or a single
> return value. While the second entry point would be used when the number
> of arguments is different from 1. Depending on number of arguments
> accepted, one or the other of the entry points may point directly to
> code raising an error).

Mh... I have very few functions accepting a single argument.
How  would  one  implement  continuations  when  a  function
argument is in a register  (rather than on the Scheme stack,
however implemented)?  In a complex way I presume.

  Something  similar can  be done  for return  values[1]; in
Vicare every function call site has 2 return points: one for
single return value; the other for 0, 2, more return values.
One return  point goes  on with  the computation,  the other
raises an exception.

  If the callee  returns a single value: it just  does a RET
to the address that was pushed  on the stack by CALL.  If it
returns multiple values: it  computes the other return point
address which  is at  a fixed  offset from  the single-value
return point.  It is complex to setup this thing...


[1]  Ashley and  Dybvig.   "An  Efficient Implementation  of
Multiple Return Values in  Scheme".  Proceedings of the 1994
ACM Conference on Lisp  and Functional Programming, 140-149,
Orlando, June 1994.
-- 
"Now feel the funk blast!"
Rage Against the Machine - "Calm like a bomb"