Re: Small LAP peephole optimization

[Ken Raeburn]

On May 9, 2007, at 06:19, Dmitry Antipov wrote:
> Hello again,
>
> this is a minor LAP peephole optimization intended to remove redundant
> '(byte-constant 0) (byte-plus . 0)' byte code insns. As an obvious
> example, for
>
> (disassemble (byte-compile '(lambda (x y) (+ x (* 2 y)))))
>
> it will produce
>
> 0       varref    x
> 1       varref    y
> 2       dup
> 3       plus
> 4       plus
> 5       return
>
> instead of current
>
> 0       varref    x
> 1       varref    y
> 2       dup
> 3       plus
> 4       constant  0
> 5       plus
> 6       plus
> 7       return

This looks like a nice little optimization, yes.  But consider that  
+0 is not always a no-op.  If the other value is not numeric, an  
error will be thrown, and in fact you could use the one-argument form  
of + as a cheap way to test for a numeric value.  So, in a less  
obvious example:

(defun foo (x y) (+ (quux 2 y)))

becomes:

byte code for foo:
  args: (x y)
0       constant  quux
1       constant  2
2       varref    y
3       call      2
4       constant  0
5       plus    
6       return  

Now if the author of "foo" isn't sure that "quux" is going to return  
a numeric value, removing the addition changes the semantics of "foo".

> During full bootstrap, this small optimization is performed for more
> than 100 LAPs, thus removing ~400 byte code insns. It was also  
> tested by
> byte-force-recompile of all lisp, and hopefully it works.

I would guess that in most of these cases it's a safe optimization,  
but you should really check.  If the previous operation is guaranteed  
to leave a numeric value at the top of the stack, as in your example,  
and no other code can branch to the +0 sequence, then you can do the  
optimization; otherwise, you probably shouldn't.  (An opcode like  
plus that generates a numeric value if it doesn't throw an error is  
easy.  Harder is figuring out after popping values off the stack  
whether the next value left at the top is numeric, especially in the  
face of branches.)

Ken