Bug 148916 – DFG should have a debugging option that runs a phase that flushes all locals

• Component: JavaScriptCore
• Status: RESOLVED FIXED

[Saam Barati]

And maybe it's worth considering if we want to enable this for some run mode of run-javascriptcore-tests to ensure it doesn't break.

[Saam Barati]

Created attachment 260808 [details]
patch

[Saam Barati]

Comment on attachment 260808 [details]
patch

View in context: https://bugs.webkit.org/attachment.cgi?id=260808&action=review

> Tools/Scripts/run-jsc-stress-tests:791
> +        runDFGFlushEverything

Should we have this as part of the default run or no?

[Filip Pizlo]

Comment on attachment 260808 [details]
patch

View in context: https://bugs.webkit.org/attachment.cgi?id=260808&action=review

> Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj:1037
> +		79B531EA1B9CEE180039CC8E /* DFGFlushEverythingInsertionPhase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 79B531E81B9CEE180039CC8E /* DFGFlushEverythingInsertionPhase.cpp */; };
> +		79B531EB1B9CEE180039CC8E /* DFGFlushEverythingInsertionPhase.h in Headers */ = {isa = PBXBuildFile; fileRef = 79B531E91B9CEE180039CC8E /* DFGFlushEverythingInsertionPhase.h */; settings = {ATTRIBUTES = (Private, ); }; };

I would call this MaximalFlushInsertionPhase.  The names of the phases are meant to parse in English when used in the following two forms:

phase name: "Maximal Flush Insertion Phase"
command: "perform Maximal Flush Insertion"

I think that "Maximal Flush Insertion" is more grammatical than "Flush Everything Insertion", particularly in the two uses above.

> Source/JavaScriptCore/dfg/DFGFlushEverythingInsertionPhase.cpp:48
> +        RELEASE_ASSERT(m_graph.m_form == LoadStore);

DFG_ASSERT(m_graph, nullptr, m_graph.m_form == LoadStore)

> Source/JavaScriptCore/dfg/DFGFlushEverythingInsertionPhase.cpp:52
> +        for (BasicBlock* block : m_graph.blocksInPreOrder()) {

m_graph.blocksInNaturalOrder() is what you should use if you don't care about the order.

> Source/JavaScriptCore/dfg/DFGFlushEverythingInsertionPhase.cpp:60
> +            if (!treatedRootBlock) {
> +                treatRootBlock(block, insertionSet, currentBlockAccessData);
> +                treatedRootBlock = true;
> +                isRootBlock = true;
> +            }

I think you're doing this in the loop so that treatRegularBlock() doesn't see the SetLocals that this inserted.  I sort of buy that.  If you want to do that, then I recommend this code:

if (block == m_graph.block(0))
    treatRootBlock(block, insertionSet, currentBlockAccessData);

But this phase doesn't need to be super fast.  It just needs to be accurate.  So, I would recommend calling treatRootBlock() *after* this loop.  It will need to use its own insertion set and it will essentially recompute currentBlockAccessData, but that's fine.  It's more clear that way.

> Source/JavaScriptCore/dfg/DFGFlushEverythingInsertionPhase.cpp:76
> +            if (node->op() != SetLocal && node->op() != SetArgument)
> +                continue;

If you change this so that you're searching forward to find the first VariableAccessData* for each local, then you can just use hasVariableAccessData() instead of casing for particular node types.

> Source/JavaScriptCore/dfg/DFGFlushEverythingInsertionPhase.cpp:88
> +            if (hasSetInRootBlock.operand(operand))
> +                return;

This seems like a strange behavior.  It means that if you have a local that is assigned in the root block, then its initial undefined value will not be flushed.  I think that it would be good to avoid this kind of inconsistency.  I recommend having this phase unconditionally insert SetLocal(Undefined) for any non-argument at the top of the root block, and use the search above to find the right VariableAccessData* to use.

> Source/JavaScriptCore/dfg/DFGFlushEverythingInsertionPhase.cpp:99
> +        for (unsigned i = 0; i < block->variablesAtTail.numberOfArguments(); i++)
> +            insertSetLocal(virtualRegisterForArgument(i));

I think that this is unnecessary because:

1) It's wrong.  You don't want to set any arguments to Undefined.
2) It's dead code.  Every argument will have a SetArgument in the root block, so hasSetInRootBlock.operand(virtualRegisterForArgument(i)) is always true.

Instead, I think that you should make the intent more deliberate: you want to set every local to Undefined but you don't want to set any arguments to anything, instead relying on the fact that the arguments already have values.

> Source/JavaScriptCore/dfg/DFGFlushEverythingInsertionPhase.cpp:102
> +    void treatRegularBlock(BasicBlock* block, InsertionSet& insertionSet, Operands<VariableAccessData*>& currentBlockAccessData, bool isRootBlock)

In general, instead of passing around isRootBlock, you could say "block == m_graph.block(0)".

> Source/JavaScriptCore/dfg/DFGFlushEverythingInsertionPhase.cpp:113
> +                case SetArgument:
> +                case SetLocal: {

I think that you only want to insert Flush before SetLocal.  I don't think it makes sense to insert Flush before SetArgument.

> Source/JavaScriptCore/dfg/DFGFlushEverythingInsertionPhase.cpp:128
> +                        if (isRootBlock) {
> +                            // We don't want to flush before the very first SetLocal/SetArgument in the root block.
> +                            bool alreadySkippedSetLocal = skippedSetAlreadyBecauseRoot.operand(operand);
> +                            if (!alreadySkippedSetLocal) {
> +                                skippedSetAlreadyBecauseRoot.operand(operand) = true;
> +                                continue;
> +                            }
> +                        }

You could get rid of this if you just unconditionally SetLocal(Undefined) at the top of the root block.

> Source/JavaScriptCore/dfg/DFGFlushEverythingInsertionPhase.cpp:141
> +                case Flush: {
> +                    VariableAccessData* accessData = node->variableAccessData();
> +                    VirtualRegister operand = accessData->local();
> +                    currentBlockAccessData.operand(operand) = accessData;

Outside of this switch statement, you could have "if (node->hasVariableAccessData()) currentBlockAccessData.operand(node->local()) = node->variableAccessData()".  That way, you don't have to case on node types to figure out if it has variable access data and you don't need to have two copies of this code.

> Source/JavaScriptCore/dfg/DFGFlushEverythingInsertionPhase.h:35
> +
> +bool performFlushEverythingInsertionPhase(Graph& graph);

You should put a comment here describing what this phase is about.

[Saam Barati]

Comment on attachment 260808 [details]
patch

View in context: https://bugs.webkit.org/attachment.cgi?id=260808&action=review

>> Source/JavaScriptCore/dfg/DFGFlushEverythingInsertionPhase.cpp:99
>> +            insertSetLocal(virtualRegisterForArgument(i));
> 
> I think that this is unnecessary because:
> 
> 1) It's wrong.  You don't want to set any arguments to Undefined.
> 2) It's dead code.  Every argument will have a SetArgument in the root block, so hasSetInRootBlock.operand(virtualRegisterForArgument(i)) is always true.
> 
> Instead, I think that you should make the intent more deliberate: you want to set every local to Undefined but you don't want to set any arguments to anything, instead relying on the fact that the arguments already have values.

Thanks for your review. The code is much cleaner now.
I have a question on (2), I don't see why this holds just by looking at the varargs inlining code in byte code parser.
BytecodeParser, when inlining a a varargs call, will add SetArgument nodes to the graph. Why is it then that (2) holds?

[Saam Barati]

Created attachment 260834 [details]
patch

[Saam Barati]

Comment on attachment 260834 [details]
patch

View in context: https://bugs.webkit.org/attachment.cgi?id=260834&action=review

> Source/JavaScriptCore/dfg/DFGMaximalFlushInsertionPhase.cpp:117
> +            // FIXME: maybe we should assert this is always a Flush. But would this ever be a GetLocal?

Fil, do you have any comments on this?

[Saam Barati]

Created attachment 260835 [details]
patch

switch to DFG_ASSERT

[WebKit Commit Bot]

Attachment 260835 [details] did not pass style-queue:


ERROR: Source/JavaScriptCore/dfg/DFGMaximalFlushInsertionPhase.cpp:88:  Place brace on its own line for function definitions.  [whitespace/braces] [4]
ERROR: Source/JavaScriptCore/dfg/DFGMaximalFlushInsertionPhase.h:51:  The parameter name "graph" adds no information, so it should be removed.  [readability/parameter_name] [5]
ERROR: Source/JavaScriptCore/dfg/DFGPlan.cpp:45:  Alphabetical sorting problem.  [build/include_order] [4]
Total errors found: 3 in 10 files


If any of these errors are false positives, please file a bug against check-webkit-style.

[Saam Barati]

Comment on attachment 260834 [details]
patch

View in context: https://bugs.webkit.org/attachment.cgi?id=260834&action=review

>> Source/JavaScriptCore/dfg/DFGMaximalFlushInsertionPhase.cpp:117
>> +            // FIXME: maybe we should assert this is always a Flush. But would this ever be a GetLocal?
> 
> Fil, do you have any comments on this?

What I really mean here, is, when we loop over numberOfLocals below, if we cached operand=>node here, should
we assert that all those nodes were Flushes. (Obviously we may encounter SetArguments here).

[Filip Pizlo]

(In reply to comment #4)
> Comment on attachment 260808 [details]
> patch
> 
> View in context:
> https://bugs.webkit.org/attachment.cgi?id=260808&action=review
> 
> >> Source/JavaScriptCore/dfg/DFGFlushEverythingInsertionPhase.cpp:99
> >> +            insertSetLocal(virtualRegisterForArgument(i));
> > 
> > I think that this is unnecessary because:
> > 
> > 1) It's wrong.  You don't want to set any arguments to Undefined.
> > 2) It's dead code.  Every argument will have a SetArgument in the root block, so hasSetInRootBlock.operand(virtualRegisterForArgument(i)) is always true.
> > 
> > Instead, I think that you should make the intent more deliberate: you want to set every local to Undefined but you don't want to set any arguments to anything, instead relying on the fact that the arguments already have values.
> 
> Thanks for your review. The code is much cleaner now.
> I have a question on (2), I don't see why this holds just by looking at the
> varargs inlining code in byte code parser.
> BytecodeParser, when inlining a a varargs call, will add SetArgument nodes
> to the graph. Why is it then that (2) holds?

Had to think about this a bit, and in the process I think that I found an error in some of my other feedback.

But first, your question.  First of all, for (2) to be true, there needs to be at least one [sic] SetLocal or SetArgument to that argument in the root block.  So, if varargs inserted some additional SetArgument nodes, it would have no impact on the fact that there was already at least one SetArgument in the root block, since we insert a SetArgument for every argument in the root block.  But anyway, varargs inserts SetArgument nodes for calls to inlined functions, not for the arguments to the function we're compiling.  So, if it did emit a SetArgument node, it would not be for an argument - it would be for a local.

And now, the error: I told you to not insert Flushes before SetArguments.  That's wrong.  Failure to insert a Flush before a SetArgument would mean that we aren't flushing whatever the last value of the local was prior to that SetArgument.  So, you had it right by looking for both SetArgument and SetLocal nodes, and prepending Flush nodes to them.  It's true that when you do this, your Flush inserter must not insert a Flush before those SetArgument nodes that already happened to be there.  You basically need to be able to ask "is this one of the SetArguments that I am using as the initial value of this local?".  Luckily there is a way to ask this question:

if (node->op() == SetArgument) {
    if (node->local().isArgument() && node == m_graph.m_arguments[node->local().toArgument()])
        // this node is a primordial SetArgument that represents the value of the local from before the start of IR execution.
}

[Filip Pizlo]

Comment on attachment 260835 [details]
patch

View in context: https://bugs.webkit.org/attachment.cgi?id=260835&action=review

LGTM, but I think you also need to Flush before SetArgument, provided that it's not a primordial SetArgument.

> Source/JavaScriptCore/dfg/DFGMaximalFlushInsertionPhase.cpp:70
> +                if (node->op() == SetLocal) {

I was wrong before.  You also need to consider those SetArgument nodes that are not primordial (i.e. they don't belong to m_graph.m_arguments).

> Source/JavaScriptCore/dfg/DFGMaximalFlushInsertionPhase.cpp:118
> +            // FIXME: maybe we should assert this is always a Flush. But would this ever be a GetLocal?
> +            // Do we ever have GetLocals before a SetLocal in the root block?

This is interesting.  The first access to a local in the root block cannot be a GetLocal.  It should be either a SetLocal or SetArgument.  Due to your other transformation, it'll be either SetArgument or Flush.

[Saam Barati]

Comment on attachment 260835 [details]
patch

View in context: https://bugs.webkit.org/attachment.cgi?id=260835&action=review

>> Source/JavaScriptCore/dfg/DFGMaximalFlushInsertionPhase.cpp:118
>> +            // Do we ever have GetLocals before a SetLocal in the root block?
> 
> This is interesting.  The first access to a local in the root block cannot be a GetLocal.  It should be either a SetLocal or SetArgument.  Due to your other transformation, it'll be either SetArgument or Flush.

So, if we do see the first node as being a SetArgument here, then it must be a primordial SetArgument node (otherwise we would have inserted a Flush before it).
Should we still then insert a SetLocal(Undefined) prior to the primordial node? Or should we skip such SetLocals?

[Saam Barati]

Created attachment 260845 [details]
patch

[WebKit Commit Bot]

Attachment 260845 [details] did not pass style-queue:


ERROR: Source/JavaScriptCore/dfg/DFGMaximalFlushInsertionPhase.cpp:89:  Place brace on its own line for function definitions.  [whitespace/braces] [4]
Total errors found: 1 in 10 files


If any of these errors are false positives, please file a bug against check-webkit-style.

[Saam Barati]

Some performance numbers as an experiment to see the penalty of turning this on:

VMs tested:
"og" at /Users/saambarati/WK/Clean/WebKitBuild/Release/jsc (r189532)
"flush" at /Users/saambarati/WK/ternary/WebKitBuild/Release/jsc (r189532)
    export JSC_enableMaximalFlushInsertionPhase=1

Collected 10 samples per benchmark/VM, with 10 VM invocations per benchmark. Emitted a call to gc() between sample measurements.
Used 1 benchmark iteration per VM invocation for warm-up. Used the jsc-specific preciseTime() function to get microsecond-level
timing. Reporting benchmark execution times with 95% confidence intervals in milliseconds.

                                                            og                      flush                                       
SunSpider:
   3d-cube                                            6.4755+-1.3743            6.1424+-0.3787          might be 1.0542x faster
   3d-morph                                           6.6136+-0.8172     !      9.4456+-1.0623        ! definitely 1.4282x slower
   3d-raytrace                                        7.8758+-1.1171     ?      9.1533+-1.4357        ? might be 1.1622x slower
   access-binary-trees                                3.3455+-0.6262     ?      3.7128+-0.7768        ? might be 1.1098x slower
   access-fannkuch                                    7.6505+-0.7021     !     13.6345+-1.1741        ! definitely 1.7822x slower
   access-nbody                                       2.9725+-0.3136     !      3.8264+-0.2817        ! definitely 1.2873x slower
   access-nsieve                                      3.8612+-0.2273     ?      4.5258+-0.8317        ? might be 1.1721x slower
   bitops-3bit-bits-in-byte                           1.7207+-0.4163     !      2.8676+-0.3093        ! definitely 1.6666x slower
   bitops-bits-in-byte                                4.0922+-0.2879     ?      4.2477+-0.4752        ? might be 1.0380x slower
   bitops-bitwise-and                                 2.2932+-0.0456     !      6.0569+-0.2203        ! definitely 2.6412x slower
   bitops-nsieve-bits                                 4.1909+-0.8229     !     16.9594+-0.8995        ! definitely 4.0467x slower
   controlflow-recursive                              3.7956+-0.8616     ?      4.3204+-0.6235        ? might be 1.1383x slower
   crypto-aes                                         4.6878+-0.4036     !      8.5556+-1.5396        ! definitely 1.8251x slower
   crypto-md5                                         3.0358+-0.3988     ?      3.9798+-0.6452        ? might be 1.3110x slower
   crypto-sha1                                        3.6357+-0.7153            3.3074+-0.2253          might be 1.0993x faster
   date-format-tofte                                  9.5870+-0.2603     !     11.4124+-1.0823        ! definitely 1.1904x slower
   date-format-xparb                                  5.6403+-0.3881     !      7.4350+-1.2285        ! definitely 1.3182x slower
   math-cordic                                        4.2436+-0.6257     !      7.9952+-1.6071        ! definitely 1.8840x slower
   math-partial-sums                                  5.8466+-0.4142     !      7.2021+-0.3569        ! definitely 1.2319x slower
   math-spectral-norm                                 3.0351+-0.6890     !      4.5550+-0.5845        ! definitely 1.5008x slower
   regexp-dna                                         7.7560+-0.7649            7.1574+-0.2536          might be 1.0836x faster
   string-base64                                      5.7308+-0.8192     ?      6.2714+-1.2159        ? might be 1.0943x slower
   string-fasta                                       8.7600+-1.7726     !     13.0052+-2.0591        ! definitely 1.4846x slower
   string-tagcloud                                    9.9262+-0.6069     !     11.9114+-1.0513        ! definitely 1.2000x slower
   string-unpack-code                                26.2628+-2.5058           25.0744+-2.2236          might be 1.0474x faster
   string-validate-input                              6.8533+-0.9303     ?      7.0679+-0.9044        ? might be 1.0313x slower

   <arithmetic>                                       6.1495+-0.1439     !      8.0701+-0.2622        ! definitely 1.3123x slower

                                                            og                      flush                                       
LongSpider:
   3d-cube                                          986.3528+-10.3882    !   1031.8449+-12.6571       ! definitely 1.0461x slower
   3d-morph                                        1848.9913+-21.0805    ?   1861.3791+-18.2894       ?
   3d-raytrace                                      776.9968+-41.2581    ?    824.0996+-5.9851        ? might be 1.0606x slower
   access-binary-trees                             1087.5335+-11.9101    !   1185.0039+-4.9847        ! definitely 1.0896x slower
   access-fannkuch                                  350.5218+-3.2144     !   1683.8007+-16.2968       ! definitely 4.8037x slower
   access-nbody                                     632.2262+-8.8302     !    852.5363+-6.0429        ! definitely 1.3485x slower
   access-nsieve                                    572.8992+-4.6685     !   1106.0133+-6.0152        ! definitely 1.9306x slower
   bitops-3bit-bits-in-byte                          43.1412+-2.3015     !    138.7816+-2.7007        ! definitely 3.2169x slower
   bitops-bits-in-byte                               99.7509+-6.8719     !    152.4313+-7.6513        ! definitely 1.5281x slower
   bitops-nsieve-bits                               596.2120+-3.7789     !    740.5570+-11.6822       ! definitely 1.2421x slower
   controlflow-recursive                            536.2677+-9.3553          535.7968+-6.1016        
   crypto-aes                                       712.8685+-6.4402     !   3360.8066+-30.8215       ! definitely 4.7145x slower
   crypto-md5                                       613.6552+-26.6674    !    829.6543+-37.2248       ! definitely 1.3520x slower
   crypto-sha1                                      791.3703+-30.3242    !   2251.4377+-99.8072       ! definitely 2.8450x slower
   date-format-tofte                                611.1212+-7.2368     ?    612.7934+-6.4772        ?
   date-format-xparb                                796.5434+-4.9867     !    874.4074+-8.9806        ! definitely 1.0978x slower
   hash-map                                         199.7482+-3.5486     !    285.6361+-12.8789       ! definitely 1.4300x slower
   math-cordic                                      605.3922+-9.1437     !    683.1072+-9.5399        ! definitely 1.1284x slower
   math-partial-sums                                582.6919+-6.6212     !    611.3866+-21.6257       ! definitely 1.0492x slower
   math-spectral-norm                               688.3118+-5.8348     !   2341.8443+-20.5792       ! definitely 3.4023x slower
   string-base64                                    447.2260+-4.1232     !    460.8508+-6.3296        ! definitely 1.0305x slower
   string-fasta                                     459.6027+-10.9716    !    719.4856+-8.2178        ! definitely 1.5655x slower
   string-tagcloud                                  221.3917+-2.7579     !    233.3106+-4.2087        ! definitely 1.0538x slower

   <geometric>                                      495.9340+-2.4693     !    759.7270+-3.0344        ! definitely 1.5319x slower

                                                            og                      flush                                       
V8Spider:
   crypto                                            94.8586+-3.5770     !    276.1156+-5.6876        ! definitely 2.9108x slower
   deltablue                                        149.7938+-15.5448    !    218.4037+-5.3969        ! definitely 1.4580x slower
   earley-boyer                                      77.8475+-5.0552     !    126.6976+-10.2494       ! definitely 1.6275x slower
   raytrace                                          63.7298+-7.3514     !    167.8530+-14.3517       ! definitely 2.6338x slower
   regexp                                            79.4428+-2.5620     ?     81.7718+-2.0992        ? might be 1.0293x slower
   richards                                         116.7410+-4.8730     !    165.1984+-8.4731        ! definitely 1.4151x slower
   splay                                             68.2214+-5.0650     ?     71.4285+-10.6122       ? might be 1.0470x slower

   <geometric>                                       88.7072+-1.1428     !    142.6580+-3.6462        ! definitely 1.6082x slower

                                                            og                      flush                                       
Octane:
   encrypt                                           0.20833+-0.00219    !     1.64099+-0.01495       ! definitely 7.8768x slower
   decrypt                                           4.11218+-0.04958    !    29.59152+-0.30892       ! definitely 7.1961x slower
   deltablue                                x2       0.19316+-0.00501    !     0.39175+-0.00924       ! definitely 2.0280x slower
   earley                                            0.36940+-0.00461    !     0.69386+-0.00701       ! definitely 1.8783x slower
   boyer                                             5.61721+-0.03895    !     5.76294+-0.09224       ! definitely 1.0259x slower
   navier-stokes                            x2       5.96279+-0.03181    !    19.67241+-0.17705       ! definitely 3.2992x slower
   raytrace                                 x2       1.27117+-0.03471    !     8.14602+-0.25205       ! definitely 6.4083x slower
   richards                                 x2       0.13635+-0.00234    !     0.15132+-0.00210       ! definitely 1.1098x slower
   splay                                    x2       0.57314+-0.02375    ?     0.64384+-0.05069       ? might be 1.1233x slower
   regexp                                   x2      32.20959+-0.55590    !    34.95541+-0.29008       ! definitely 1.0852x slower
   pdfjs                                    x2      48.61470+-1.44142    !    74.64875+-1.19304       ! definitely 1.5355x slower
   mandreel                                 x2      74.27947+-2.84910    !   145.90357+-9.56777       ! definitely 1.9643x slower
   gbemu                                    x2      63.13872+-2.44900    !   103.79944+-6.19983       ! definitely 1.6440x slower
   closure                                           0.71367+-0.03379          0.70335+-0.00465         might be 1.0147x faster
   jquery                                            9.16253+-0.13578          9.10879+-0.07827       
   box2d                                    x2      17.63766+-0.27134    !    39.86000+-0.87973       ! definitely 2.2599x slower
   zlib                                     x2     488.99212+-8.53742    !  2216.60297+-28.75483      ! definitely 4.5330x slower
   typescript                               x2    1009.89226+-41.82195   !  2111.40337+-52.23943      ! definitely 2.0907x slower

   <geometric>                                       7.81414+-0.04852    !    16.33091+-0.08677       ! definitely 2.0899x slower

                                                            og                      flush                                       
Kraken:
   ai-astar                                          278.866+-4.920      ^     240.490+-12.914        ^ definitely 1.1596x faster
   audio-beat-detection                               62.770+-1.912      !     443.506+-17.910        ! definitely 7.0656x slower
   audio-dft                                         138.224+-1.634      !     619.470+-4.812         ! definitely 4.4817x slower
   audio-fft                                          41.938+-1.392      !     378.318+-3.210         ! definitely 9.0208x slower
   audio-oscillator                                   73.863+-2.448      !      84.509+-1.902         ! definitely 1.1441x slower
   imaging-darkroom                                   78.734+-5.339      !     128.095+-12.593        ! definitely 1.6269x slower
   imaging-desaturate                                 79.888+-2.877      !      98.080+-12.020        ! definitely 1.2277x slower
   imaging-gaussian-blur                             105.801+-1.225      !    2670.923+-14.659        ! definitely 25.2448x slower
   json-parse-financial                               48.941+-1.630      ?      49.052+-1.831         ?
   json-stringify-tinderbox                           28.361+-1.511      ?      29.028+-1.806         ? might be 1.0235x slower
   stanford-crypto-aes                                52.205+-3.029      !      69.305+-4.135         ! definitely 1.3275x slower
   stanford-crypto-ccm                                48.476+-5.088      ?      51.123+-3.648         ? might be 1.0546x slower
   stanford-crypto-pbkdf2                            115.529+-2.310      !     131.612+-9.622         ! definitely 1.1392x slower
   stanford-crypto-sha256-iterative                   46.548+-3.903      ?      49.198+-2.559         ? might be 1.0569x slower

   <arithmetic>                                       85.725+-1.103      !     360.193+-2.649         ! definitely 4.2017x slower

                                                            og                      flush                                       
JSRegress:
   abc-forward-loop-equal                            36.2369+-1.5910     ?     36.8451+-1.5136        ? might be 1.0168x slower
   abc-postfix-backward-loop                         38.4581+-3.6916           36.1085+-1.6206          might be 1.0651x faster
   abc-simple-backward-loop                          35.6084+-0.6875     ?     36.1783+-1.4550        ? might be 1.0160x slower
   abc-simple-forward-loop                           35.9196+-1.2207     ?     36.9598+-1.3882        ? might be 1.0290x slower
   abc-skippy-loop                                   26.1297+-1.1851     ?     30.0142+-4.7898        ? might be 1.1487x slower
   abs-boolean                                        4.2531+-1.2975     !     19.3236+-5.4636        ! definitely 4.5434x slower
   adapt-to-double-divide                            19.0427+-0.6309     ?     19.8230+-1.0605        ? might be 1.0410x slower
   aliased-arguments-getbyval                         1.5630+-0.1784            1.5410+-0.1467          might be 1.0143x faster
   allocate-big-object                                2.8970+-0.2622     !      5.2094+-1.1949        ! definitely 1.7982x slower
   arguments-named-and-reflective                    13.0180+-1.0919     !     21.5797+-1.2849        ! definitely 1.6577x slower
   arguments-out-of-bounds                           10.8698+-0.4764     ?     11.8577+-0.8397        ? might be 1.0909x slower
   arguments-strict-mode                             11.5181+-0.5805     !     21.2183+-1.4619        ! definitely 1.8422x slower
   arguments                                          9.7277+-0.4208     !     19.4979+-1.4178        ! definitely 2.0044x slower
   arity-mismatch-inlining                            1.1466+-0.1064     !      2.4599+-0.3752        ! definitely 2.1454x slower
   array-access-polymorphic-structure                 6.6236+-0.2953     !     11.9403+-0.4399        ! definitely 1.8027x slower
   array-nonarray-polymorhpic-access                 32.1410+-3.9112     !    121.5956+-5.8815        ! definitely 3.7832x slower
   array-prototype-every                             94.1156+-3.0431     ?     99.0219+-2.8021        ? might be 1.0521x slower
   array-prototype-forEach                           97.7763+-9.7905     ?     99.4583+-5.4616        ? might be 1.0172x slower
   array-prototype-map                              106.4638+-13.3644         105.2023+-3.8074          might be 1.0120x faster
   array-prototype-reduce                            91.6383+-3.4412     !     98.0850+-2.7725        ! definitely 1.0703x slower
   array-prototype-reduceRight                       95.0788+-6.2936     !    330.7264+-133.7211      ! definitely 3.4784x slower
   array-prototype-some                              94.1731+-3.1109     ?    100.7670+-3.9325        ? might be 1.0700x slower
   array-splice-contiguous                           24.5892+-1.0344     ?     25.0117+-1.2646        ? might be 1.0172x slower
   array-with-double-add                              4.6191+-0.5037     !     17.8230+-1.1763        ! definitely 3.8585x slower
   array-with-double-increment                        4.8849+-1.0672     !     21.2274+-0.8173        ! definitely 4.3455x slower
   array-with-double-mul-add                          5.8231+-0.8361     !     19.6176+-0.8416        ! definitely 3.3689x slower
   array-with-double-sum                              3.9224+-0.4721     !     10.5637+-0.6528        ! definitely 2.6931x slower
   array-with-int32-add-sub                           7.2990+-1.0520     !     27.0044+-1.2790        ! definitely 3.6997x slower
   array-with-int32-or-double-sum                     4.6833+-0.6236     !     10.2377+-1.1663        ! definitely 2.1860x slower
   ArrayBuffer-DataView-alloc-large-long-lived   
                                                     40.1973+-4.4443     ?     41.9108+-3.0707        ? might be 1.0426x slower
   ArrayBuffer-DataView-alloc-long-lived             17.4900+-4.9675           15.9530+-0.8451          might be 1.0963x faster
   ArrayBuffer-Int32Array-byteOffset                  4.2590+-0.1849     !     56.0901+-1.7925        ! definitely 13.1699x slower
   ArrayBuffer-Int8Array-alloc-large-long-lived   
                                                     38.5888+-2.1469     ?     43.2180+-3.7880        ? might be 1.1200x slower
   ArrayBuffer-Int8Array-alloc-long-lived-buffer   
                                                     24.4612+-1.2645     !     29.4157+-1.7662        ! definitely 1.2025x slower
   ArrayBuffer-Int8Array-alloc-long-lived            14.2633+-0.8176     !     15.8942+-0.5954        ! definitely 1.1143x slower
   ArrayBuffer-Int8Array-alloc                       12.3252+-0.6221     !     14.3099+-0.8270        ! definitely 1.1610x slower
   arrowfunction-call                                14.4289+-1.1569     !     23.4082+-1.8670        ! definitely 1.6223x slower
   asmjs_bool_bug                                     9.6811+-0.7120     !     25.5718+-4.6831        ! definitely 2.6414x slower
   assign-custom-setter-polymorphic                   2.8131+-0.1252     ?      2.9217+-0.1885        ? might be 1.0386x slower
   assign-custom-setter                               4.3260+-0.6512            4.2207+-0.7175          might be 1.0249x faster
   basic-set                                         13.3983+-1.7246           13.1190+-1.2141          might be 1.0213x faster
   big-int-mul                                        4.8923+-0.8293     !     11.1212+-0.7961        ! definitely 2.2732x slower
   boolean-test                                       3.6345+-0.2439     !      9.3721+-0.8178        ! definitely 2.5786x slower
   branch-fold                                        5.1593+-1.1317     !     15.2857+-1.5919        ! definitely 2.9628x slower
   branch-on-string-as-boolean                       20.5817+-1.0587     !    188.2343+-9.5655        ! definitely 9.1457x slower
   by-val-generic                                     3.4852+-0.9387     !      7.0102+-0.6465        ! definitely 2.0114x slower
   call-spread-apply                                 38.1132+-2.3438     ?     41.3398+-2.8373        ? might be 1.0847x slower
   call-spread-call                                  32.0654+-2.7988     ?     32.9398+-1.8339        ? might be 1.0273x slower
   captured-assignments                               0.5537+-0.1370     ?      0.5609+-0.0606        ? might be 1.0131x slower
   cast-int-to-double                                 8.0809+-1.9312     !     24.0669+-1.5250        ! definitely 2.9782x slower
   cell-argument                                      7.8215+-0.7967     ?      8.6214+-1.0893        ? might be 1.1023x slower
   cfg-simplify                                       3.6302+-0.3321     !     16.5681+-1.6980        ! definitely 4.5640x slower
   chain-getter-access                               10.6837+-0.5138     !     32.9755+-1.9395        ! definitely 3.0865x slower
   cmpeq-obj-to-obj-other                            16.3178+-1.8925     !     21.4969+-1.1624        ! definitely 1.3174x slower
   constant-test                                      7.2209+-1.9719     !     30.4463+-1.0282        ! definitely 4.2164x slower
   create-lots-of-functions                          13.0061+-1.0946           12.6707+-0.8475          might be 1.0265x faster
   cse-new-array-buffer                               2.7004+-0.2896     ?      3.7300+-0.7904        ? might be 1.3813x slower
   cse-new-array                                      2.8946+-0.3602     !      4.9702+-1.5382        ! definitely 1.7170x slower
   DataView-custom-properties                        43.1387+-2.4015     ?     46.6504+-1.6149        ? might be 1.0814x slower
   delay-tear-off-arguments-strictmode               15.6605+-0.9905     ?     17.3408+-1.2989        ? might be 1.1073x slower
   deltablue-varargs                                256.7865+-26.2379    !    494.3535+-7.3611        ! definitely 1.9252x slower
   destructuring-arguments                          205.1812+-4.1031     !    239.7262+-22.7441       ! definitely 1.1684x slower
   destructuring-parameters-overridden-by-function   
                                                      0.7164+-0.1527            0.6647+-0.2112          might be 1.0778x faster
   destructuring-swap                                 6.5506+-0.7190     !     16.4976+-0.8554        ! definitely 2.5185x slower
   direct-arguments-getbyval                          1.4086+-0.1575     ?      1.7538+-0.3392        ? might be 1.2451x slower
   div-boolean-double                                 5.9781+-0.1262     !     17.1858+-2.3253        ! definitely 2.8748x slower
   div-boolean                                        9.2585+-0.2872     !     16.8307+-1.9740        ! definitely 1.8179x slower
   double-get-by-val-out-of-bounds                    6.2255+-0.7216     !      9.2747+-2.0831        ! definitely 1.4898x slower
   double-pollution-getbyval                         10.0823+-0.7109     !     13.4969+-0.4461        ! definitely 1.3387x slower
   double-pollution-putbyoffset                       5.6852+-1.9779     !     11.6257+-2.3126        ! definitely 2.0449x slower
   double-real-use                                   28.8953+-1.3447     ?     31.9679+-2.0721        ? might be 1.1063x slower
   double-to-int32-typed-array-no-inline              3.0676+-0.3657     !      4.2497+-0.1576        ! definitely 1.3854x slower
   double-to-int32-typed-array                        2.8201+-0.2846     ?      3.4303+-0.5793        ? might be 1.2164x slower
   double-to-uint32-typed-array-no-inline             3.3543+-0.7309     ?      5.1137+-1.4893        ? might be 1.5245x slower
   double-to-uint32-typed-array                       2.8142+-0.1931     !      3.6139+-0.4440        ! definitely 1.2842x slower
   elidable-new-object-dag                           46.3427+-1.6536     !    383.1435+-4.5447        ! definitely 8.2676x slower
   elidable-new-object-roflcopter                    44.2102+-2.5504     !     84.0348+-14.6290       ! definitely 1.9008x slower
   elidable-new-object-then-call                     39.3565+-1.0407     !    328.4919+-4.2910        ! definitely 8.3466x slower
   elidable-new-object-tree                          51.5827+-2.1613     !    372.6899+-3.5277        ! definitely 7.2251x slower
   empty-string-plus-int                              6.5535+-1.4651     ?      8.3255+-1.1904        ? might be 1.2704x slower
   emscripten-cube2hash                              38.0299+-1.7908     !     43.8591+-2.9333        ! definitely 1.1533x slower
   exit-length-on-plain-object                       15.1953+-1.0233     ?     16.2955+-1.7607        ? might be 1.0724x slower
   external-arguments-getbyval                        1.5006+-0.1500     ?      1.6693+-0.3213        ? might be 1.1124x slower
   external-arguments-putbyval                        3.0386+-0.7179            2.7756+-0.3185          might be 1.0948x faster
   fixed-typed-array-storage-var-index                1.6211+-0.3203     !      2.6029+-0.1639        ! definitely 1.6056x slower
   fixed-typed-array-storage                          1.3412+-0.4183     !      2.1509+-0.3166        ! definitely 1.6037x slower
   Float32Array-matrix-mult                           4.6122+-0.4043     !     14.1384+-1.6629        ! definitely 3.0654x slower
   Float32Array-to-Float64Array-set                  58.9069+-8.1720     !    140.2476+-5.1763        ! definitely 2.3808x slower
   Float64Array-alloc-long-lived                     87.0905+-9.1038     !    209.1907+-3.5556        ! definitely 2.4020x slower
   Float64Array-to-Int16Array-set                    73.1120+-6.5942     !    155.3192+-5.1075        ! definitely 2.1244x slower
   fold-double-to-int                                14.4433+-0.6667     !     28.4853+-3.4887        ! definitely 1.9722x slower
   fold-get-by-id-to-multi-get-by-offset-rare-int   
                                                     16.2968+-1.8056     !     29.2257+-0.8944        ! definitely 1.7933x slower
   fold-get-by-id-to-multi-get-by-offset             15.7767+-2.7428     !     28.6864+-3.0272        ! definitely 1.8183x slower
   fold-multi-get-by-offset-to-get-by-offset   
                                                     14.5865+-1.9321     !     23.5783+-1.1925        ! definitely 1.6164x slower
   fold-multi-get-by-offset-to-poly-get-by-offset   
                                                     13.9940+-1.1554     !     22.9715+-1.7125        ! definitely 1.6415x slower
   fold-multi-put-by-offset-to-poly-put-by-offset   
                                                     14.1350+-1.8678     !     24.2919+-3.2653        ! definitely 1.7186x slower
   fold-multi-put-by-offset-to-put-by-offset   
                                                      8.9274+-1.6666     !     20.9736+-2.3411        ! definitely 2.3493x slower
   fold-multi-put-by-offset-to-replace-or-transition-put-by-offset   
                                                     15.0437+-2.2198     !     25.0214+-1.9026        ! definitely 1.6633x slower
   fold-put-by-id-to-multi-put-by-offset             16.7672+-2.5838     !     24.1920+-1.3224        ! definitely 1.4428x slower
   fold-put-by-val-with-string-to-multi-put-by-offset   
                                                     15.8056+-1.7919     !     25.0901+-1.5448        ! definitely 1.5874x slower
   fold-put-by-val-with-symbol-to-multi-put-by-offset   
                                                     16.6414+-2.4914     !     25.2231+-1.4244        ! definitely 1.5157x slower
   fold-put-structure                                 9.6407+-2.7432     !     18.9726+-0.9975        ! definitely 1.9680x slower
   for-of-iterate-array-entries                      14.1694+-2.0111     !     18.0928+-1.3780        ! definitely 1.2769x slower
   for-of-iterate-array-keys                          4.7365+-0.5921     ?      5.4310+-0.5810        ? might be 1.1466x slower
   for-of-iterate-array-values                        5.2173+-0.8548            5.1474+-0.5871          might be 1.0136x faster
   fround                                            20.9188+-0.6834     !    117.1662+-1.9544        ! definitely 5.6010x slower
   ftl-library-inlining-dataview                     73.5906+-2.0658     !     86.8898+-2.4924        ! definitely 1.1807x slower
   ftl-library-inlining                             124.2193+-2.4074     !    162.3463+-10.4739       ! definitely 1.3069x slower
   function-call                                     13.5845+-0.5068     !     22.2193+-0.6902        ! definitely 1.6356x slower
   function-dot-apply                                 3.5512+-1.1468     !     13.4200+-0.7761        ! definitely 3.7790x slower
   function-test                                      3.4983+-0.4685     !      9.7888+-1.0762        ! definitely 2.7982x slower
   function-with-eval                               124.6163+-2.5951     ^    118.4492+-2.2798        ^ definitely 1.0521x faster
   gcse-poly-get-less-obvious                        16.8511+-0.9114     !     24.5656+-0.6818        ! definitely 1.4578x slower
   gcse-poly-get                                     19.4942+-0.8727     !     25.2003+-0.9371        ! definitely 1.2927x slower
   gcse                                               5.9769+-0.9823     !     20.5536+-0.5872        ! definitely 3.4388x slower
   get-by-id-bimorphic-check-structure-elimination-simple   
                                                      3.4257+-0.3817     !      6.7776+-0.4321        ! definitely 1.9784x slower
   get-by-id-bimorphic-check-structure-elimination   
                                                      7.3161+-1.0568     !     27.5379+-1.4041        ! definitely 3.7640x slower
   get-by-id-chain-from-try-block                     6.4805+-0.2792            6.3278+-0.2074          might be 1.0241x faster
   get-by-id-check-structure-elimination              7.0885+-2.5671     !     22.4256+-0.7793        ! definitely 3.1637x slower
   get-by-id-proto-or-self                           20.1523+-1.8790     !     60.8088+-1.6905        ! definitely 3.0175x slower
   get-by-id-quadmorphic-check-structure-elimination-simple   
                                                      3.8960+-0.4494     !      7.3301+-0.7466        ! definitely 1.8814x slower
   get-by-id-self-or-proto                           22.1856+-3.0034     !     61.4364+-2.0132        ! definitely 2.7692x slower
   get-by-val-out-of-bounds                           6.9009+-1.2803     ?      8.9898+-2.6326        ? might be 1.3027x slower
   get-by-val-with-string-bimorphic-check-structure-elimination-simple   
                                                      3.6171+-0.3908     !      6.5019+-0.1865        ! definitely 1.7975x slower
   get-by-val-with-string-bimorphic-check-structure-elimination   
                                                      8.1378+-1.3899     !     44.8433+-1.2782        ! definitely 5.5105x slower
   get-by-val-with-string-chain-from-try-block   
                                                      6.7893+-0.6502            6.5742+-0.5373          might be 1.0327x faster
   get-by-val-with-string-check-structure-elimination   
                                                      6.4010+-0.7396     !     34.9073+-1.4368        ! definitely 5.4534x slower
   get-by-val-with-string-proto-or-self              19.1684+-1.0331     !     62.1516+-1.6500        ! definitely 3.2424x slower
   get-by-val-with-string-quadmorphic-check-structure-elimination-simple   
                                                      4.7652+-1.0811     !      7.1636+-0.5301        ! definitely 1.5033x slower
   get-by-val-with-string-self-or-proto              21.0238+-2.1847     !     62.8205+-1.7583        ! definitely 2.9881x slower
   get-by-val-with-symbol-bimorphic-check-structure-elimination-simple   
                                                      4.2852+-0.6608     !      7.1046+-0.6481        ! definitely 1.6579x slower
   get-by-val-with-symbol-bimorphic-check-structure-elimination   
                                                     20.1847+-2.4568     !     40.9891+-1.5891        ! definitely 2.0307x slower
   get-by-val-with-symbol-chain-from-try-block   
                                                      6.4933+-0.2982            6.4924+-0.2668        
   get-by-val-with-symbol-check-structure-elimination   
                                                     16.2686+-2.0628     !     38.7757+-1.8159        ! definitely 2.3835x slower
   get-by-val-with-symbol-proto-or-self              20.2952+-1.3293     !     64.6987+-3.4841        ! definitely 3.1879x slower
   get-by-val-with-symbol-quadmorphic-check-structure-elimination-simple   
                                                      4.9643+-0.7995     !      7.6127+-0.7014        ! definitely 1.5335x slower
   get-by-val-with-symbol-self-or-proto              21.6627+-2.6810     !     61.9943+-1.8829        ! definitely 2.8618x slower
   get_callee_monomorphic                             4.6729+-1.3657     !      7.9187+-1.6666        ! definitely 1.6946x slower
   get_callee_polymorphic                             3.8980+-0.5189     !     11.4289+-1.4680        ! definitely 2.9320x slower
   getter-no-activation                               7.0242+-1.5534     !     23.5575+-1.0730        ! definitely 3.3537x slower
   getter-prototype                                  11.7370+-0.6768     !     15.0888+-1.9689        ! definitely 1.2856x slower
   getter-richards                                  208.7221+-17.9131    !    354.8555+-11.3760       ! definitely 1.7001x slower
   getter                                             8.8970+-0.9809     !     21.3742+-3.7127        ! definitely 2.4024x slower
   global-object-access-with-mutating-structure   
                                                      7.9831+-1.0914            7.9659+-0.7604        
   global-var-const-infer-fire-from-opt               1.0016+-0.2676            0.8986+-0.1004          might be 1.1146x faster
   global-var-const-infer                             0.9620+-0.2065            0.7925+-0.0696          might be 1.2139x faster
   hard-overflow-check-equal                         40.5881+-1.5243     !     44.9469+-1.7957        ! definitely 1.1074x slower
   hard-overflow-check                               40.1301+-1.4012     !     44.6665+-1.7326        ! definitely 1.1130x slower
   HashMap-put-get-iterate-keys                      52.5608+-4.2018     !     75.6922+-5.2835        ! definitely 1.4401x slower
   HashMap-put-get-iterate                           52.9183+-7.5641     !     74.2751+-4.7750        ! definitely 1.4036x slower
   HashMap-string-put-get-iterate                    42.3989+-5.1755     !     83.6054+-12.1558       ! definitely 1.9719x slower
   hoist-make-rope                                   11.8137+-0.6652     ?     12.9692+-1.1106        ? might be 1.0978x slower
   hoist-poly-check-structure-effectful-loop   
                                                      6.3422+-1.3643     ?      9.1316+-1.5300        ? might be 1.4398x slower
   hoist-poly-check-structure                         4.6680+-0.6013     !      6.1999+-0.6861        ! definitely 1.3282x slower
   imul-double-only                                   9.2800+-1.1242     ?     10.3639+-1.0776        ? might be 1.1168x slower
   imul-int-only                                     10.5328+-1.3136     !     13.8904+-0.6364        ! definitely 1.3188x slower
   imul-mixed                                         8.9117+-1.0609     !     12.9668+-1.3950        ! definitely 1.4550x slower
   in-four-cases                                     22.8276+-2.0746     !     27.1950+-1.0831        ! definitely 1.1913x slower
   in-one-case-false                                 19.0893+-5.0241           18.1751+-0.6301          might be 1.0503x faster
   in-one-case-true                                  15.5210+-1.4276     ?     17.2963+-0.5694        ? might be 1.1144x slower
   in-two-cases                                      15.5184+-1.3943     !     18.3199+-1.1636        ! definitely 1.1805x slower
   indexed-properties-in-objects                      3.8268+-0.5142     ?      4.5459+-0.4213        ? might be 1.1879x slower
   infer-closure-const-then-mov-no-inline             5.1927+-1.5539     ?      6.8443+-1.3474        ? might be 1.3181x slower
   infer-closure-const-then-mov                      23.5951+-1.0511     !     77.3867+-9.7216        ! definitely 3.2798x slower
   infer-closure-const-then-put-to-scope-no-inline   
                                                     11.9400+-0.4520     !     28.7938+-1.2700        ! definitely 2.4115x slower
   infer-closure-const-then-put-to-scope             26.9369+-0.7376     !    135.4386+-2.3720        ! definitely 5.0280x slower
   infer-closure-const-then-reenter-no-inline   
                                                     55.4021+-2.4284     !    135.6624+-3.5846        ! definitely 2.4487x slower
   infer-closure-const-then-reenter                  27.9515+-1.1787     !    136.1804+-2.8693        ! definitely 4.8720x slower
   infer-constant-global-property                     4.3422+-0.5824     !     34.6919+-1.3402        ! definitely 7.9895x slower
   infer-constant-property                            3.4117+-0.5334     !     20.1033+-2.1260        ! definitely 5.8924x slower
   infer-one-time-closure-ten-vars                    9.0290+-0.5946     ?     10.7989+-1.9634        ? might be 1.1960x slower
   infer-one-time-closure-two-vars                    8.9368+-0.7504     ?      9.0528+-0.7868        ? might be 1.0130x slower
   infer-one-time-closure                             8.7344+-0.5005     ?      9.7772+-1.3689        ? might be 1.1194x slower
   infer-one-time-deep-closure                       12.9463+-1.0072     ?     14.5968+-2.6068        ? might be 1.1275x slower
   inline-arguments-access                            5.3688+-0.7133     !      7.9195+-0.8497        ! definitely 1.4751x slower
   inline-arguments-aliased-access                    5.0132+-0.3607     !      8.2745+-0.7581        ! definitely 1.6505x slower
   inline-arguments-local-escape                      5.1780+-0.6714     !      8.2256+-0.8362        ! definitely 1.5886x slower
   inline-get-scoped-var                              5.9087+-0.6100     !     15.0081+-2.0512        ! definitely 2.5400x slower
   inlined-put-by-id-transition                      12.8620+-0.9233     !     20.5158+-2.4995        ! definitely 1.5951x slower
   inlined-put-by-val-with-string-transition   
                                                     92.0535+-10.4707    ?     94.1393+-3.5350        ? might be 1.0227x slower
   inlined-put-by-val-with-symbol-transition   
                                                     87.0357+-3.8408     ?     99.2666+-11.1930       ? might be 1.1405x slower
   int-or-other-abs-then-get-by-val                   5.7901+-0.7903     !     13.0004+-0.5193        ! definitely 2.2453x slower
   int-or-other-abs-zero-then-get-by-val             18.9187+-1.8591     !     35.1314+-3.6222        ! definitely 1.8570x slower
   int-or-other-add-then-get-by-val                   6.8373+-2.6033     !     21.8582+-3.8979        ! definitely 3.1969x slower
   int-or-other-add                                   7.7194+-2.4695     !     18.3746+-0.8007        ! definitely 2.3803x slower
   int-or-other-div-then-get-by-val                   4.5402+-0.4645     !     10.6128+-0.7782        ! definitely 2.3375x slower
   int-or-other-max-then-get-by-val                   4.4627+-0.2050     !     13.2897+-1.8469        ! definitely 2.9780x slower
   int-or-other-min-then-get-by-val                   4.5274+-0.4220     !     13.1027+-1.5816        ! definitely 2.8941x slower
   int-or-other-mod-then-get-by-val                   4.1331+-0.2138     !     10.3755+-0.6169        ! definitely 2.5103x slower
   int-or-other-mul-then-get-by-val                   4.6000+-0.7620     !     13.0182+-1.1320        ! definitely 2.8300x slower
   int-or-other-neg-then-get-by-val                   5.5203+-1.2761     !     12.8440+-0.7784        ! definitely 2.3267x slower
   int-or-other-neg-zero-then-get-by-val             19.4502+-2.6198     !     33.2040+-1.1882        ! definitely 1.7071x slower
   int-or-other-sub-then-get-by-val                   5.2088+-0.9778     !     21.4134+-1.3163        ! definitely 4.1110x slower
   int-or-other-sub                                   4.2792+-0.4854     !     17.6304+-1.1386        ! definitely 4.1200x slower
   int-overflow-local                                 6.3099+-2.1352     !     20.0244+-1.0933        ! definitely 3.1735x slower
   Int16Array-alloc-long-lived                       58.7143+-2.3246     !    176.2055+-2.5309        ! definitely 3.0011x slower
   Int16Array-bubble-sort-with-byteLength            22.9224+-2.5537     !    167.6531+-3.2031        ! definitely 7.3140x slower
   Int16Array-bubble-sort                            22.5332+-1.0715     !    165.7354+-3.7791        ! definitely 7.3552x slower
   Int16Array-load-int-mul                            2.7540+-1.9854     ?      4.3138+-0.6768        ? might be 1.5664x slower
   Int16Array-to-Int32Array-set                      57.9792+-5.5828     !    135.9252+-2.4811        ! definitely 2.3444x slower
   Int32Array-alloc-large                            13.4997+-0.7216           13.4947+-0.6153        
   Int32Array-alloc-long-lived                       67.2095+-2.8275     !    185.3483+-3.2665        ! definitely 2.7578x slower
   Int32Array-alloc                                   3.3480+-0.1441     !     12.1094+-0.6615        ! definitely 3.6168x slower
   Int32Array-Int8Array-view-alloc                    8.5204+-1.0707     ?      9.9158+-0.5412        ? might be 1.1638x slower
   int52-spill                                        5.6178+-0.4976     !      7.8764+-0.9944        ! definitely 1.4020x slower
   Int8Array-alloc-long-lived                        49.2457+-1.8184     !    168.9125+-2.6052        ! definitely 3.4300x slower
   Int8Array-load-with-byteLength                     4.4459+-0.7002     ?      5.0690+-1.1252        ? might be 1.1402x slower
   Int8Array-load                                     4.3267+-0.3802            4.1923+-0.2135          might be 1.0321x faster
   integer-divide                                    13.4728+-1.4025     !     38.9909+-2.6587        ! definitely 2.8940x slower
   integer-modulo                                     2.2507+-0.3318     ?      2.3192+-0.6046        ? might be 1.0304x slower
   is-boolean-fold-tricky                             4.6336+-0.3807     !     40.0188+-1.7900        ! definitely 8.6367x slower
   is-boolean-fold                                    3.5681+-0.4345     !     40.3766+-4.4992        ! definitely 11.3159x slower
   is-function-fold-tricky-internal-function   
                                                     12.6308+-1.3900     !     64.7312+-2.2639        ! definitely 5.1249x slower
   is-function-fold-tricky                            4.7707+-0.6351     !     65.9397+-5.2015        ! definitely 13.8219x slower
   is-function-fold                                   3.4196+-0.1994     !     57.6359+-1.5674        ! definitely 16.8544x slower
   is-number-fold-tricky                              4.9429+-0.7854     !     39.8758+-1.8367        ! definitely 8.0673x slower
   is-number-fold                                     3.6564+-0.6610     !     39.2987+-0.9036        ! definitely 10.7480x slower
   is-object-or-null-fold-functions                   3.4802+-0.3256     !     63.2132+-2.4791        ! definitely 18.1639x slower
   is-object-or-null-fold-less-tricky                 5.5565+-0.9301     !     57.9133+-1.4846        ! definitely 10.4226x slower
   is-object-or-null-fold-tricky                      6.3273+-1.9640     !     58.6008+-4.9430        ! definitely 9.2616x slower
   is-object-or-null-fold                             3.5485+-0.5388     !     57.4842+-1.4712        ! definitely 16.1996x slower
   is-object-or-null-trickier-function                4.6817+-0.4450     !     70.7637+-11.4575       ! definitely 15.1149x slower
   is-object-or-null-trickier-internal-function   
                                                     12.6362+-1.3150     !     84.7006+-2.3037        ! definitely 6.7030x slower
   is-object-or-null-tricky-function                  5.2824+-0.9259     !     61.6878+-1.7306        ! definitely 11.6781x slower
   is-object-or-null-tricky-internal-function   
                                                     11.3121+-1.9161     !     61.3288+-1.5657        ! definitely 5.4215x slower
   is-string-fold-tricky                              4.3635+-0.2015     !     42.9304+-6.8784        ! definitely 9.8385x slower
   is-string-fold                                     3.3063+-0.1938     !     39.1142+-1.3810        ! definitely 11.8301x slower
   is-undefined-fold-tricky                           4.0644+-0.5880     !     37.9107+-1.5697        ! definitely 9.3274x slower
   is-undefined-fold                                  3.5675+-0.6150     !     39.5000+-2.5921        ! definitely 11.0723x slower
   JSONP-negative-0                                   0.3187+-0.0398     ?      0.3352+-0.0398        ? might be 1.0519x slower
   large-int-captured                                 6.6284+-0.9842     ?      6.7652+-1.3071        ? might be 1.0206x slower
   large-int-neg                                     17.7499+-1.3269     ?     17.8587+-0.8557        ?
   large-int                                         15.6849+-0.8655     ?     16.7169+-0.8138        ? might be 1.0658x slower
   load-varargs-elimination                          24.5343+-0.5830     !    101.0584+-4.0822        ! definitely 4.1191x slower
   logical-not-weird-types                            4.2276+-0.9032     !      8.0032+-1.2538        ! definitely 1.8931x slower
   logical-not                                        5.6143+-0.9678     !     10.0175+-0.9738        ! definitely 1.7843x slower
   lots-of-fields                                    11.2842+-1.0352     ?     13.2509+-1.8930        ? might be 1.1743x slower
   make-indexed-storage                               4.1772+-0.7153            3.6693+-0.2748          might be 1.1384x faster
   make-rope-cse                                      4.9659+-0.4463     !     17.1632+-1.2979        ! definitely 3.4562x slower
   marsaglia-larger-ints                             40.9223+-3.9692     !    337.9191+-4.4497        ! definitely 8.2576x slower
   marsaglia-osr-entry                               26.1932+-1.3750     !    235.0953+-4.6408        ! definitely 8.9754x slower
   math-with-out-of-bounds-array-values              28.7523+-2.7885     ?     29.1496+-2.7996        ? might be 1.0138x slower
   max-boolean                                        3.9564+-0.6864     !     23.0802+-0.8798        ! definitely 5.8336x slower
   method-on-number                                  18.2689+-0.3956     !     22.7109+-1.1523        ! definitely 1.2431x slower
   min-boolean                                        3.3705+-0.2560     !     23.4064+-3.4204        ! definitely 6.9445x slower
   minus-boolean-double                               3.9931+-0.4473     !     17.8640+-4.0415        ! definitely 4.4737x slower
   minus-boolean                                      2.9460+-0.2471     !     15.6392+-0.6275        ! definitely 5.3085x slower
   misc-strict-eq                                    38.1254+-3.3074     !    277.4525+-4.2441        ! definitely 7.2774x slower
   mod-boolean-double                                13.2034+-0.5772     !     24.7171+-1.0452        ! definitely 1.8720x slower
   mod-boolean                                        9.2789+-0.2263     !     47.4875+-1.5158        ! definitely 5.1178x slower
   mul-boolean-double                                 4.3112+-0.2003     !     15.8345+-0.6221        ! definitely 3.6729x slower
   mul-boolean                                        4.2944+-1.5226     !     17.5113+-3.0244        ! definitely 4.0777x slower
   neg-boolean                                        3.7730+-0.3176     !     14.3991+-0.4316        ! definitely 3.8163x slower
   negative-zero-divide                               0.4387+-0.0229            0.4359+-0.0185        
   negative-zero-modulo                               0.4500+-0.0423     ?      0.4740+-0.1191        ? might be 1.0532x slower
   negative-zero-negate                               0.4143+-0.0491     ?      0.4621+-0.0537        ? might be 1.1156x slower
   nested-function-parsing                           53.7693+-2.6419     ?     55.9494+-0.8708        ? might be 1.0405x slower
   new-array-buffer-dead                            117.9383+-4.4844     !    128.8156+-3.2865        ! definitely 1.0922x slower
   new-array-buffer-push                              7.6528+-0.3258     !     13.0722+-1.9744        ! definitely 1.7082x slower
   new-array-dead                                    19.9125+-2.1405     !    175.3632+-2.2423        ! definitely 8.8067x slower
   new-array-push                                     5.3215+-0.6580     !      8.2686+-0.9185        ! definitely 1.5538x slower
   no-inline-constructor                             40.9579+-1.3909     !     69.3798+-2.1550        ! definitely 1.6939x slower
   number-test                                        3.5924+-0.3216     !      8.5958+-0.2227        ! definitely 2.3927x slower
   object-closure-call                                7.8067+-1.0353     !     16.6759+-0.6527        ! definitely 2.1361x slower
   object-get-own-property-symbols-on-large-array   
                                                      5.0529+-0.4812            4.5991+-0.2405          might be 1.0987x faster
   object-test                                        3.7323+-0.4689     !      9.9879+-0.9859        ! definitely 2.6760x slower
   obvious-sink-pathology-taken                     132.9863+-1.7820     !    266.4994+-4.0600        ! definitely 2.0040x slower
   obvious-sink-pathology                           128.3428+-3.3598     !    222.2878+-3.6189        ! definitely 1.7320x slower
   obviously-elidable-new-object                     39.5181+-2.7647     !    217.5721+-2.3406        ! definitely 5.5056x slower
   plus-boolean-arith                                 3.1805+-0.3958     !     13.4702+-0.5692        ! definitely 4.2353x slower
   plus-boolean-double                                3.6560+-0.1119     !     20.7110+-0.5764        ! definitely 5.6649x slower
   plus-boolean                                       3.5553+-0.6016     !     20.3255+-0.7949        ! definitely 5.7170x slower
   poly-chain-access-different-prototypes-simple   
                                                      4.3825+-0.6384     !      6.3326+-0.2091        ! definitely 1.4450x slower
   poly-chain-access-different-prototypes             4.1479+-0.4492     !      6.7883+-0.4267        ! definitely 1.6366x slower
   poly-chain-access-simpler                          4.2150+-0.4309     !      6.7003+-0.5677        ! definitely 1.5896x slower
   poly-chain-access                                  4.3766+-0.7424     !      6.3009+-0.1473        ! definitely 1.4397x slower
   poly-stricteq                                     63.3683+-1.4464     !    173.7628+-4.7418        ! definitely 2.7421x slower
   polymorphic-array-call                             1.7815+-0.4437     ?      2.1294+-0.2368        ? might be 1.1952x slower
   polymorphic-get-by-id                              3.3923+-0.2653     !      4.9760+-1.1175        ! definitely 1.4669x slower
   polymorphic-put-by-id                             29.9508+-0.8734     !     32.3879+-1.5561        ! definitely 1.0814x slower
   polymorphic-put-by-val-with-string                32.0327+-1.7706     ?     33.8009+-1.4157        ? might be 1.0552x slower
   polymorphic-put-by-val-with-symbol                30.0580+-1.2529     !     35.0311+-2.0604        ! definitely 1.1654x slower
   polymorphic-structure                             15.6949+-0.7022     !     72.8844+-3.1071        ! definitely 4.6438x slower
   polyvariant-monomorphic-get-by-id                 11.0788+-1.0677     !     36.0304+-2.1938        ! definitely 3.2522x slower
   proto-getter-access                               10.9920+-0.8198     !     33.5039+-1.2537        ! definitely 3.0480x slower
   prototype-access-with-mutating-prototype           7.4747+-0.7040     ?      8.4605+-1.1711        ? might be 1.1319x slower
   put-by-id-replace-and-transition                   9.6918+-1.1376     !     14.0371+-1.0388        ! definitely 1.4483x slower
   put-by-id-slightly-polymorphic                     3.5475+-0.4101     !      4.8743+-0.8292        ! definitely 1.3740x slower
   put-by-id                                         15.2245+-1.5722     !     39.0799+-1.3854        ! definitely 2.5669x slower
   put-by-val-direct                                  0.4409+-0.0412     ?      0.5633+-0.2072        ? might be 1.2776x slower
   put-by-val-large-index-blank-indexing-type   
                                                      6.5604+-0.8096     ?      7.4476+-0.6552        ? might be 1.1352x slower
   put-by-val-machine-int                             3.1236+-0.4260     !      8.4699+-0.6124        ! definitely 2.7116x slower
   put-by-val-with-string-replace-and-transition   
                                                     15.4233+-1.4809     !     21.9935+-1.1713        ! definitely 1.4260x slower
   put-by-val-with-string-slightly-polymorphic   
                                                      3.7784+-0.3497     !      5.9395+-0.8641        ! definitely 1.5720x slower
   put-by-val-with-string                            15.0273+-0.8015     !     44.5506+-2.6395        ! definitely 2.9646x slower
   put-by-val-with-symbol-replace-and-transition   
                                                     16.0079+-1.4694     !     21.2311+-1.5060        ! definitely 1.3263x slower
   put-by-val-with-symbol-slightly-polymorphic   
                                                      4.3782+-0.8310     !      5.8390+-0.5212        ! definitely 1.3337x slower
   put-by-val-with-symbol                            16.1651+-1.9525     !     43.6369+-2.1282        ! definitely 2.6995x slower
   rare-osr-exit-on-local                            17.5793+-2.1222     !     22.1360+-1.7243        ! definitely 1.2592x slower
   register-pressure-from-osr                        19.2285+-0.4855     !     30.5737+-1.6897        ! definitely 1.5900x slower
   repeat-multi-get-by-offset                        25.9802+-1.1731     !     40.4344+-2.0533        ! definitely 1.5564x slower
   setter-prototype                                  10.2299+-0.9010     ?     11.9988+-1.2441        ? might be 1.1729x slower
   setter                                             8.3947+-0.5623     !     17.2484+-0.4705        ! definitely 2.0547x slower
   simple-activation-demo                            30.4850+-1.2812     ^     21.2868+-1.4074        ^ definitely 1.4321x faster
   simple-getter-access                              13.8254+-1.6532     !     49.4520+-1.7668        ! definitely 3.5769x slower
   simple-poly-call-nested                           12.3222+-1.3590     ?     14.3152+-0.6636        ? might be 1.1617x slower
   simple-poly-call                                   1.7571+-0.3615     ?      1.9461+-0.2613        ? might be 1.1076x slower
   sin-boolean                                       23.9516+-1.8362     !     27.2089+-0.7587        ! definitely 1.1360x slower
   singleton-scope                                   71.8764+-5.5603     !    120.2474+-12.2424       ! definitely 1.6730x slower
   sink-function                                     12.9145+-0.8941     !     16.4322+-1.4109        ! definitely 1.2724x slower
   sink-huge-activation                              19.0061+-1.3264     !     33.9748+-2.2591        ! definitely 1.7876x slower
   sinkable-new-object-dag                           74.4398+-3.0207     !    411.7730+-4.0284        ! definitely 5.5316x slower
   sinkable-new-object-taken                         57.5688+-2.0080     !    263.7635+-4.7913        ! definitely 4.5817x slower
   sinkable-new-object                               40.1321+-2.4958     !    226.5844+-2.8291        ! definitely 5.6460x slower
   slow-array-profile-convergence                     4.4752+-1.7772     ?      6.1125+-0.6224        ? might be 1.3659x slower
   slow-convergence                                   2.8415+-0.2345     !      4.7941+-0.8181        ! definitely 1.6872x slower
   slow-ternaries                                    20.1699+-0.6580     !     67.8537+-2.3657        ! definitely 3.3641x slower
   sorting-benchmark                                 21.3766+-1.2767     !     32.8064+-5.0816        ! definitely 1.5347x slower
   sparse-conditional                                 1.5777+-0.1668     !      4.4415+-0.6127        ! definitely 2.8152x slower
   splice-to-remove                                  14.5874+-1.1946     !     21.8753+-5.7244        ! definitely 1.4996x slower
   string-char-code-at                               16.7470+-1.3709     !     26.7406+-1.0017        ! definitely 1.5967x slower
   string-concat-object                               2.7770+-0.2810     !      3.8235+-0.4012        ! definitely 1.3769x slower
   string-concat-pair-object                          2.6507+-0.1567     !      3.7127+-0.3542        ! definitely 1.4007x slower
   string-concat-pair-simple                         12.7577+-1.2290     !     23.8633+-1.4613        ! definitely 1.8705x slower
   string-concat-simple                              12.5810+-1.1017     !     23.3063+-1.4723        ! definitely 1.8525x slower
   string-cons-repeat                                 8.8282+-0.9787     !     18.4953+-1.1553        ! definitely 2.0950x slower
   string-cons-tower                                  9.4249+-1.0383            8.9007+-0.2492          might be 1.0589x faster
   string-equality                                   19.5441+-0.8409     !     45.9753+-2.0289        ! definitely 2.3524x slower
   string-get-by-val-big-char                         8.7064+-0.8391     !     29.2584+-1.2275        ! definitely 3.3606x slower
   string-get-by-val-out-of-bounds-insane             3.6912+-0.1633     !      4.5787+-0.6864        ! definitely 1.2404x slower
   string-get-by-val-out-of-bounds                    5.3067+-0.6636     !     40.5687+-7.3024        ! definitely 7.6448x slower
   string-get-by-val                                  3.8554+-0.5275     !      6.5041+-0.4795        ! definitely 1.6870x slower
   string-hash                                        3.1771+-0.6988     !      5.9874+-0.7403        ! definitely 1.8845x slower
   string-long-ident-equality                        15.6375+-0.6197     !     41.1622+-1.6110        ! definitely 2.6323x slower
   string-out-of-bounds                              12.2673+-0.4123     ?     12.4015+-0.9158        ? might be 1.0109x slower
   string-repeat-arith                               32.8656+-1.0940     ?     33.0811+-1.0553        ?
   string-sub                                        62.5581+-1.6278     !     67.0464+-1.7746        ! definitely 1.0717x slower
   string-test                                        3.6645+-0.3983     !      8.6608+-0.5897        ! definitely 2.3635x slower
   string-var-equality                               33.2771+-3.6004     !     66.8456+-2.0205        ! definitely 2.0088x slower
   structure-hoist-over-transitions                   3.1062+-0.2626     !      4.8012+-0.5452        ! definitely 1.5457x slower
   substring-concat-weird                            46.7654+-1.5306     !    106.1436+-2.7419        ! definitely 2.2697x slower
   substring-concat                                  52.6562+-2.4365     !     98.6371+-2.4882        ! definitely 1.8732x slower
   substring                                         54.8445+-1.6401     !     95.1347+-2.9813        ! definitely 1.7346x slower
   switch-char-constant                               3.9276+-0.6907     !     12.2836+-0.5980        ! definitely 3.1275x slower
   switch-char                                        9.2670+-0.4650     !     14.7153+-0.6990        ! definitely 1.5879x slower
   switch-constant                                   10.4661+-1.3055     !     21.0040+-2.2980        ! definitely 2.0069x slower
   switch-string-basic-big-var                       17.3224+-1.7040     !     36.3158+-2.2610        ! definitely 2.0965x slower
   switch-string-basic-big                           17.4259+-1.0087     !     30.2600+-1.8698        ! definitely 1.7365x slower
   switch-string-basic-var                           15.7900+-1.0064     !     35.3478+-7.2804        ! definitely 2.2386x slower
   switch-string-basic                               13.9976+-0.1540     !     27.7222+-1.1819        ! definitely 1.9805x slower
   switch-string-big-length-tower-var                21.7060+-1.3038     !     37.6562+-1.9627        ! definitely 1.7348x slower
   switch-string-length-tower-var                    15.4286+-0.7221     !     29.5419+-1.3146        ! definitely 1.9148x slower
   switch-string-length-tower                        13.8021+-0.5783     !     26.2857+-1.0053        ! definitely 1.9045x slower
   switch-string-short                               14.8100+-0.8622     !     26.2789+-1.3194        ! definitely 1.7744x slower
   switch                                            14.5742+-1.3046     !     24.8220+-1.8528        ! definitely 1.7031x slower
   tear-off-arguments-simple                          4.6098+-1.2138     !      7.5572+-0.7363        ! definitely 1.6394x slower
   tear-off-arguments                                 6.1999+-1.3919     !     10.6957+-1.6928        ! definitely 1.7251x slower
   temporal-structure                                13.9481+-1.1058     !     75.8085+-9.4283        ! definitely 5.4350x slower
   to-int32-boolean                                  15.0986+-0.5964     !     59.5669+-2.0275        ! definitely 3.9452x slower
   try-catch-get-by-val-cloned-arguments             17.3955+-1.3385     ?     18.2166+-0.6089        ? might be 1.0472x slower
   try-catch-get-by-val-direct-arguments              7.3842+-0.3806     !      9.1880+-0.4452        ! definitely 1.2443x slower
   try-catch-get-by-val-scoped-arguments              9.2681+-1.0040     ?     11.3986+-1.3181        ? might be 1.2299x slower
   typed-array-get-set-by-val-profiling              35.0747+-1.0969     !     39.3967+-2.6600        ! definitely 1.1232x slower
   undefined-property-access                        289.5199+-6.0065     !    992.0490+-7.8074        ! definitely 3.4265x slower
   undefined-test                                     3.9520+-0.8702     !      9.3533+-0.8714        ! definitely 2.3667x slower
   unprofiled-licm                                   17.5572+-1.2493     ?     18.8270+-1.1763        ? might be 1.0723x slower
   varargs-call                                      17.0667+-0.5611     !     73.9109+-7.9150        ! definitely 4.3307x slower
   varargs-construct-inline                          28.5676+-2.0357     !     78.0553+-3.6133        ! definitely 2.7323x slower
   varargs-construct                                 25.8002+-1.6392     !     86.0874+-3.7792        ! definitely 3.3367x slower
   varargs-inline                                     9.8420+-1.3100     !     51.5915+-2.1032        ! definitely 5.2420x slower
   varargs-strict-mode                               11.5740+-1.0298     !    182.3822+-6.5264        ! definitely 15.7579x slower
   varargs                                           11.8531+-2.2834     !     63.4104+-2.1146        ! definitely 5.3497x slower
   weird-inlining-const-prop                          2.7620+-0.3978     !      6.7798+-1.4681        ! definitely 2.4546x slower

   <geometric>                                       10.2636+-0.0517     !     21.7292+-0.0663        ! definitely 2.1171x slower

                                                            og                      flush                                       
Geomean of preferred means:
   <scaled-result>                                   35.0641+-0.1263     !     69.3932+-0.5994        ! definitely 1.9790x slower

[Filip Pizlo]

Comment on attachment 260845 [details]
patch

View in context: https://bugs.webkit.org/attachment.cgi?id=260845&action=review

> Tools/Scripts/run-jsc-stress-tests:806
> +        runDFGMaximalFlushPhase

I like that we are running this by default.

[Filip Pizlo]

>    crypto-aes                                       712.8685+-6.4402     !  
> 3360.8066+-30.8215       ! definitely 4.7145x slower

Can you file a bug for this?

>    raytrace                                 x2       1.27117+-0.03471    !  
> 8.14602+-0.25205       ! definitely 6.4083x slower

LOL this is a bit of a red herring.  Flushing everything means that all of our escape analyses think that the values escape, which disables object allocation elimination and varargs simplification.  Octane/raytrace is basically just a test of those optimizations.

So, I'm curious what the performance of Octane is if you exclude raytrace from the comparison.  That might give some insight into the true slow-down.

But, anyway, you should probably file a bug for this.  It would be great if we could make raytrace faster even when escape analysis fails!

>    zlib                                     x2     488.99212+-8.53742    ! 
> 2216.60297+-28.75483      ! definitely 4.5330x slower

LOL this needs a bug, I don't know why this failed so hard.

>    imaging-gaussian-blur                             105.801+-1.225      !  
> 2670.923+-14.659        ! definitely 25.2448x slower

OMG file a bug.

[Filip Pizlo]

Comment on attachment 260845 [details]
patch

View in context: https://bugs.webkit.org/attachment.cgi?id=260845&action=review

> Source/JavaScriptCore/dfg/DFGMaximalFlushInsertionPhase.cpp:133
> +            if (initialAccessNodes.operand(operand)->op() == Flush)

Remove.

> Source/JavaScriptCore/dfg/DFGMaximalFlushInsertionPhase.cpp:138
> +            else {
> +                DFG_ASSERT(m_graph, nullptr, initialAccessNodes.operand(operand)->op() == SetArgument);
> +                continue;
> +            }

Remove.

[Saam Barati]

landed in:
http://trac.webkit.org/changeset/189544