Comments on Meeting Notes

Brendan Eich brendan at mozilla.org
Fri Dec 7 20:44:45 PST 2012


Jeff Walden wrote:
> On 12/04/2012 03:57 PM, Brendan Eich wrote:
>> Allen Wirfs-Brock wrote:
>>> The timing of copying is only an issue if the function actually assigns to a formal parameter.  Such assignments should be pretty easy to (conservatively) statically check for.
>> I'm telling you what engines do. Not what they might do. I did assignment analysis in SpiderMonkey for Firefox 3.6, it was helpful in its day. I think a bunch has been ripped out because modern JITs don't need it.

Just to be clear, that assignment analysis was not used to optimize 
arguments copying for strict mode.

>> [...]the point I made, cited above: " engines don't do it currently and feel little pressure to do so. Chicken and egg."
>
> SpiderMonkey's implementation of the arguments object functions exactly as described here for functions with strict mode code -- actually for all functions, I think.  Regarding the strict mode semantics specifically, it was fairly easy to make those optimizations when I was implementing the various strict mode arguments semantics, so I did them.  There hasn't been a time where SpiderMonkey's had strict mode arguments semantics, without these optimizations.

I don't see this. Firefox 3 era (pre-ES5):

js> function f(x) { if (0) arguments; return x }
js> dis(f)
main:
00000:  getarg 0
00003:  return
00004:  stop

Source notes:

Latest SpiderMonkey:

js> function f(x) { if (0) arguments; return x }
js> dis(f)
flags:
loc     op
-----   --
00000:  arguments
00001:  setlocal 0
00004:  pop
main:
00005:  getarg 0
00008:  return
00009:  stop

Source notes:
  ofs  line    pc  delta desc     args
---- ---- ----- ------ -------- ------
   0:    1     5 [   5] colspan 34
   2:    1     9 [   4] colspan 8

js> function g(x) { "use strict"; if (0) arguments; return x }
js> dis(g)
flags:
loc     op
-----   --
00000:  arguments
00001:  setlocal 0
00004:  pop
main:
00005:  getarg 0
00008:  return
00009:  stop

Source notes:
  ofs  line    pc  delta desc     args
---- ---- ----- ------ -------- ------
   0:    3     5 [   5] colspan 16
   2:    3     5 [   0] colspan 32
   4:    3     9 [   4] colspan 8

True, no difference due to "use strict"; but both paths rely on the JIT 
to optimize away the useless arguments op. That op is emitted even 
though no code (live or dead) assigns to the formal parameter x.

Now let's go back to rev ba4d04033cd8 in the tracemonkey repo at 
hg.mozilla.org, and make the function assign to a formal somewhere in 
its control flow:

js> function f(x) { if (1) arguments; else x = 42; return x }
js> dis(f)
flags: NULL_CLOSURE
loc     op
-----   --
main:
00000:  getarg 0
00003:  return
00004:  stop

Source notes:
  off line    pc  delta desc     args
---- ---- ----- ------ -------- ------
   0:   10     0 [   0] colspan  54
   2:   10     4 [   4] colspan  1

This is optimized to avoid reifying the arguments object, which is in a 
useless expression statement so not needed.

This state of SpiderMonkey supported strict mode, as demonstrated by the 
corresponding function g:

js> function g(x) { "use strict"; if (1) arguments; else x = 42; return x }
js> dis(g)
flags: NULL_CLOSURE
loc     op
-----   --
00000:  arguments
00001:  pop
main:
00002:  getarg 0
00005:  return
00006:  stop

Source notes:
  off line    pc  delta desc     args
---- ---- ----- ------ -------- ------
   0:    8     2 [   2] colspan  68
   2:    8     6 [   4] colspan  1

Here arguments is reified because the formal x is assigned and the 
parser saw 'arguments' used albeit in a useless expression statement.

(The colspan source notes, for column index in source maps, shows I have 
a patch pushed:

$ hg log -r tip
changeset:   73898:ba4d04033cd8
tag:         bug568142-big-srcnote-fun
tag:         qbase
tag:         qtip
tag:         tip
user:        Brendan Eich <brendan at mozilla.org>
date:        Tue Oct 18 17:40:58 2011 -0700
summary:     imported patch bug568142-big-srcnote-fun

from 2011 in this old workarea, but it doesn't affect code generation.)

Some of this evolution shows how interpreter performance has mattered 
less and less (for the popular benchmarks, anyway). But it also shows 
that what I wrote was true: SpiderMonkey used to do more analysis in 
order to avoid reifying arguments objects, and ES5 strict mode in a 
function that assigns a formal required reifying on entry, to copy the 
actuals into arguments before any could be clobbered.

Other implementors should pipe up about strict mode effects on function 
code. I remember Oliver (JavaScriptCore) pointing out the 
arguments-copying requirement of strict mode as a deoptimization. See

https://mail.mozilla.org/pipermail/es5-discuss/2009-August/003144.html

and others in that thread.

/be


More information about the es-discuss mailing list