pathological byte-compilation

pathological byte-compilation

[Stefan Monnier]

CL used to define `values' as an alias to `list'.
It has been changed (end of last year) to

	(defsubst values (&rest values)
	  (apply 'list values))

This has the "interesting" side-effect that compiling the function
(defun foo () (values 1)) results in the following byte-code:

	byte code for foo:
	  args: nil
	0	constant  1
	1	list1	  
	2	varbind	  values
	3	constant  apply
	4	constant  list
	5	varref	  values
	6	call	  2
	7	unbind	  1
	8	return	  

in other words, the same result as if we had compiled
(defun foo () (let ((values (list 1))) (apply 'list values)))


	Stefan

Re: pathological byte-compilation

[Miles Bader]

"Stefan Monnier" <monnier+gnu/emacs@rum.cs.yale.edu> writes:
> 	(defsubst values (&rest values)
> 	  (apply 'list values))
>
> in other words, the same result as if we had compiled
> (defun foo () (let ((values (list 1))) (apply 'list values)))

Of course, part of the problem is that defsubst is rather pathetic, in
that it retains the argument bindings no matter what.

A very long time ago I wrote an elisp function that analyzes `let' forms
and rewrites them to eliminate as many bindings as possible (e.g., when
it can substitute a variable's initialization value in the places where
the variable is used, without changing any side-effects).

That transformation assumed a `lexical style' use of `let', which isn't
something you can do generally, but in the case of defsubst, I think it
would probably be safe to say that argument bindings are not guaranteed
to be visible (via dynamic binding) in functions called from defsubt
body.

Such an optimization might greatly improve the results of using defsubst...

-Miles
-- 
.Numeric stability is probably not all that important when you're guessing.

Re: pathological byte-compilation

[Richard Stallman]

    That transformation assumed a `lexical style' use of `let', which isn't
    something you can do generally, but in the case of defsubst, I think it
    would probably be safe to say that argument bindings are not guaranteed
    to be visible (via dynamic binding) in functions called from defsubt
    body.

I hesitate to agree with this.  However, in many defsubsts only
primitives will be called.  It should be possible to determine that
nothing called from the defsubst will ever look at variable bindings.