⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 179840 in webkit


Ignore:
Timestamp:
Feb 9, 2015, 11:57:41 AM (12 years ago)
Author:
fpizlo@apple.com
Message:

DFG should only have two mechanisms for describing effectfulness of nodes; previously there were three
​https://bugs.webkit.org/show_bug.cgi?id=141369

Reviewed by Michael Saboff.

We previously used the NodeMightClobber and NodeClobbersWorld NodeFlags to describe
effectfulness. Starting over a year ago, we introduced a more powerful mechanism - the
DFG::clobberize() function. Now we only have one remaining client of the old NodeFlags,
and everyone else uses DFG::clobberize(). We should get rid of those NodeFlags and
finally switch everyone over to DFG::clobberize().

Unfortunately there is still another place where effectfulness of nodes is described: the
AbstractInterpreter. This is because the AbstractInterpreter has special tuning both for
compile time performance and there are places where the AI is more precise than
clobberize() because of its flow-sensitivity.

This means that after this change there will be only two places, rather than three, where
the effectfulness of a node has to be described:

  • DFG::clobberize()
  • DFG::AbstractInterpreter
  • dfg/DFGClobberize.cpp:

(JSC::DFG::clobbersWorld):

  • dfg/DFGClobberize.h:
  • dfg/DFGDoesGC.cpp:

(JSC::DFG::doesGC):

  • dfg/DFGFixupPhase.cpp:

(JSC::DFG::FixupPhase::fixupNode):
(JSC::DFG::FixupPhase::attemptToMakeGetTypedArrayByteLength):
(JSC::DFG::FixupPhase::convertToGetArrayLength):
(JSC::DFG::FixupPhase::attemptToMakeGetTypedArrayByteOffset):

  • dfg/DFGGraph.h:

(JSC::DFG::Graph::isPredictedNumerical): Deleted.
(JSC::DFG::Graph::byValIsPure): Deleted.
(JSC::DFG::Graph::clobbersWorld): Deleted.

  • dfg/DFGNode.h:

(JSC::DFG::Node::convertToConstant):
(JSC::DFG::Node::convertToGetLocalUnlinked):
(JSC::DFG::Node::convertToGetByOffset):
(JSC::DFG::Node::convertToMultiGetByOffset):
(JSC::DFG::Node::convertToPutByOffset):
(JSC::DFG::Node::convertToMultiPutByOffset):

  • dfg/DFGNodeFlags.cpp:

(JSC::DFG::dumpNodeFlags):

  • dfg/DFGNodeFlags.h:
  • dfg/DFGNodeType.h:
Location:
trunk/Source/JavaScriptCore
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r179831 r179840  
     12015-02-08  Filip Pizlo  <fpizlo@apple.com>
     2
     3        DFG should only have two mechanisms for describing effectfulness of nodes; previously there were three
     4        https://bugs.webkit.org/show_bug.cgi?id=141369
     5
     6        Reviewed by Michael Saboff.
     7
     8        We previously used the NodeMightClobber and NodeClobbersWorld NodeFlags to describe
     9        effectfulness.  Starting over a year ago, we introduced a more powerful mechanism - the
     10        DFG::clobberize() function.  Now we only have one remaining client of the old NodeFlags,
     11        and everyone else uses DFG::clobberize().  We should get rid of those NodeFlags and
     12        finally switch everyone over to DFG::clobberize().
     13       
     14        Unfortunately there is still another place where effectfulness of nodes is described: the
     15        AbstractInterpreter. This is because the AbstractInterpreter has special tuning both for
     16        compile time performance and there are places where the AI is more precise than
     17        clobberize() because of its flow-sensitivity.
     18       
     19        This means that after this change there will be only two places, rather than three, where
     20        the effectfulness of a node has to be described:
     21
     22        - DFG::clobberize()
     23        - DFG::AbstractInterpreter
     24
     25        * dfg/DFGClobberize.cpp:
     26        (JSC::DFG::clobbersWorld):
     27        * dfg/DFGClobberize.h:
     28        * dfg/DFGDoesGC.cpp:
     29        (JSC::DFG::doesGC):
     30        * dfg/DFGFixupPhase.cpp:
     31        (JSC::DFG::FixupPhase::fixupNode):
     32        (JSC::DFG::FixupPhase::attemptToMakeGetTypedArrayByteLength):
     33        (JSC::DFG::FixupPhase::convertToGetArrayLength):
     34        (JSC::DFG::FixupPhase::attemptToMakeGetTypedArrayByteOffset):
     35        * dfg/DFGGraph.h:
     36        (JSC::DFG::Graph::isPredictedNumerical): Deleted.
     37        (JSC::DFG::Graph::byValIsPure): Deleted.
     38        (JSC::DFG::Graph::clobbersWorld): Deleted.
     39        * dfg/DFGNode.h:
     40        (JSC::DFG::Node::convertToConstant):
     41        (JSC::DFG::Node::convertToGetLocalUnlinked):
     42        (JSC::DFG::Node::convertToGetByOffset):
     43        (JSC::DFG::Node::convertToMultiGetByOffset):
     44        (JSC::DFG::Node::convertToPutByOffset):
     45        (JSC::DFG::Node::convertToMultiPutByOffset):
     46        * dfg/DFGNodeFlags.cpp:
     47        (JSC::DFG::dumpNodeFlags):
     48        * dfg/DFGNodeFlags.h:
     49        * dfg/DFGNodeType.h:
     50
    1512015-02-09  Csaba Osztrogonác  <ossy@webkit.org>
    252

  • trunk/Source/JavaScriptCore/dfg/DFGClobberize.cpp

    r172129 r179840  
    11/*
    2  * Copyright (C) 2013, 2014 Apple Inc. All rights reserved.
     2 * Copyright (C) 2013-2015 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    5757}
    5858
     59bool clobbersWorld(Graph& graph, Node* node)
     60{
     61    bool result = false;
     62    clobberize(
     63        graph, node, NoOpClobberize(),
     64        [&] (AbstractHeap heap) {
     65            if (heap == AbstractHeap(World))
     66                result = true;
     67        },
     68        NoOpClobberize());
     69    return result;
     70}
     71
    5972} } // namespace JSC::DFG
    6073

  • trunk/Source/JavaScriptCore/dfg/DFGClobberize.h

    r179478 r179840  
    11/*
    2  * Copyright (C) 2013, 2014 Apple Inc. All rights reserved.
     2 * Copyright (C) 2013-2015 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    935935bool writesOverlap(Graph&, Node*, AbstractHeap);
    936936
     937bool clobbersWorld(Graph&, Node*);
     938
    937939// We would have used bind() for these, but because of the overlaoding that we are doing,
    938940// it's quite a bit of clearer to just write this out the traditional way.

  • trunk/Source/JavaScriptCore/dfg/DFGDoesGC.cpp

    r179478 r179840  
    11/*
    2  * Copyright (C) 2014 Apple Inc. All rights reserved.
     2 * Copyright (C) 2014, 2015 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2929#if ENABLE(DFG_JIT)
    3030
     31#include "DFGClobberize.h"
    3132#include "DFGGraph.h"
    3233#include "DFGNode.h"
    … …  
    3738bool doesGC(Graph& graph, Node* node)
    3839{
    39     if (graph.clobbersWorld(node))
     40    if (clobbersWorld(graph, node))
    4041        return true;
    4142   

  • trunk/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp

    r179621 r179840  
    11/*
    2  * Copyright (C) 2012, 2013, 2014 Apple Inc. All rights reserved.
     2 * Copyright (C) 2012-2015 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    162162            if (attemptToMakeIntegerAdd(node)) {
    163163                node->setOp(ArithAdd);
    164                 node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
     164                node->clearFlags(NodeMustGenerate);
    165165                break;
    166166            }
    … …  
    169169                fixDoubleOrBooleanEdge(node->child2());
    170170                node->setOp(ArithAdd);
    171                 node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
     171                node->clearFlags(NodeMustGenerate);
    172172                node->setResult(NodeResultDouble);
    173173                break;
    … …  
    383383                fixEdge<BooleanUse>(node->child1());
    384384                fixEdge<BooleanUse>(node->child2());
    385                 node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
     385                node->clearFlags(NodeMustGenerate);
    386386                break;
    387387            }
    … …  
    389389                fixIntOrBooleanEdge(node->child1());
    390390                fixIntOrBooleanEdge(node->child2());
    391                 node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
     391                node->clearFlags(NodeMustGenerate);
    392392                break;
    393393            }
    … …  
    396396                fixEdge<Int52RepUse>(node->child1());
    397397                fixEdge<Int52RepUse>(node->child2());
    398                 node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
     398                node->clearFlags(NodeMustGenerate);
    399399                break;
    400400            }
    … …  
    402402                fixDoubleOrBooleanEdge(node->child1());
    403403                fixDoubleOrBooleanEdge(node->child2());
    404                 node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
     404                node->clearFlags(NodeMustGenerate);
    405405                break;
    406406            }
    … …  
    410410                fixEdge<StringIdentUse>(node->child1());
    411411                fixEdge<StringIdentUse>(node->child2());
    412                 node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
     412                node->clearFlags(NodeMustGenerate);
    413413                break;
    414414            }
    … …  
    416416                fixEdge<StringUse>(node->child1());
    417417                fixEdge<StringUse>(node->child2());
    418                 node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
     418                node->clearFlags(NodeMustGenerate);
    419419                break;
    420420            }
    … …  
    422422                fixEdge<ObjectUse>(node->child1());
    423423                fixEdge<ObjectUse>(node->child2());
    424                 node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
     424                node->clearFlags(NodeMustGenerate);
    425425                break;
    426426            }
    … …  
    428428                fixEdge<ObjectUse>(node->child1());
    429429                fixEdge<ObjectOrOtherUse>(node->child2());
    430                 node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
     430                node->clearFlags(NodeMustGenerate);
    431431                break;
    432432            }
    … …  
    434434                fixEdge<ObjectOrOtherUse>(node->child1());
    435435                fixEdge<ObjectUse>(node->child2());
    436                 node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
     436                node->clearFlags(NodeMustGenerate);
    437437                break;
    438438            }
    … …  
    830830            if (node->child1()->shouldSpeculateInt32()) {
    831831                fixEdge<Int32Use>(node->child1());
    832                 node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
     832                node->clearFlags(NodeMustGenerate);
    833833                break;
    834834            }
    … …  
    19481948        // that overflows int32.
    19491949        node->setOp(BitLShift);
    1950         node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
     1950        node->clearFlags(NodeMustGenerate);
    19511951        observeUseKindOnNode(length, Int32Use);
    19521952        observeUseKindOnNode(shiftAmount, Int32Use);
    … …  
    19591959    {
    19601960        node->setOp(GetArrayLength);
    1961         node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
     1961        node->clearFlags(NodeMustGenerate);
    19621962        fixEdge<KnownCellUse>(node->child1());
    19631963        node->setArrayMode(arrayMode);
    … …  
    19921992       
    19931993        node->setOp(GetTypedArrayByteOffset);
    1994         node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
     1994        node->clearFlags(NodeMustGenerate);
    19951995        fixEdge<KnownCellUse>(node->child1());
    19961996        return true;

  • trunk/Source/JavaScriptCore/dfg/DFGGraph.h

    r174318 r179840  
    545545   
    546546    void killUnreachableBlocks();
    547    
    548     bool isPredictedNumerical(Node* node)
    549     {
    550         return isNumerical(node->child1().useKind()) && isNumerical(node->child2().useKind());
    551     }
    552    
    553     // Note that a 'true' return does not actually mean that the ByVal access clobbers nothing.
    554     // It really means that it will not clobber the entire world. It's still up to you to
    555     // carefully consider things like:
    556     // - PutByVal definitely changes the array it stores to, and may even change its length.
    557     // - PutByOffset definitely changes the object it stores to.
    558     // - and so on.
    559     bool byValIsPure(Node* node)
    560     {
    561         switch (node->arrayMode().type()) {
    562         case Array::Generic:
    563             return false;
    564         case Array::Int32:
    565         case Array::Double:
    566         case Array::Contiguous:
    567         case Array::ArrayStorage:
    568             return !node->arrayMode().isOutOfBounds();
    569         case Array::SlowPutArrayStorage:
    570             return !node->arrayMode().mayStoreToHole();
    571         case Array::String:
    572             return node->op() == GetByVal && node->arrayMode().isInBounds();
    573 #if USE(JSVALUE32_64)
    574         case Array::Arguments:
    575             if (node->op() == GetByVal)
    576                 return true;
    577             return false;
    578 #endif // USE(JSVALUE32_64)
    579         default:
    580             return true;
    581         }
    582     }
    583    
    584     bool clobbersWorld(Node* node)
    585     {
    586         if (node->flags() & NodeClobbersWorld)
    587             return true;
    588         if (!(node->flags() & NodeMightClobber))
    589             return false;
    590         switch (node->op()) {
    591         case GetByVal:
    592         case PutByValDirect:
    593         case PutByVal:
    594         case PutByValAlias:
    595             return !byValIsPure(node);
    596         case ToString:
    597             switch (node->child1().useKind()) {
    598             case StringObjectUse:
    599             case StringOrStringObjectUse:
    600                 return false;
    601             case CellUse:
    602             case UntypedUse:
    603                 return true;
    604             default:
    605                 RELEASE_ASSERT_NOT_REACHED();
    606                 return true;
    607             }
    608         default:
    609             RELEASE_ASSERT_NOT_REACHED();
    610             return true; // If by some oddity we hit this case in release build it's safer to have CSE assume the worst.
    611         }
    612     }
    613547   
    614548    void determineReachability();

  • trunk/Source/JavaScriptCore/dfg/DFGNode.h

    r179814 r179840  
    449449        else
    450450            m_op = JSConstant;
    451         m_flags &= ~(NodeMustGenerate | NodeMightClobber | NodeClobbersWorld);
     451        m_flags &= ~NodeMustGenerate;
    452452        m_opInfo = bitwise_cast<uintptr_t>(value);
    453453        children.reset();
    … …  
    465465    {
    466466        m_op = GetLocalUnlinked;
    467         m_flags &= ~(NodeMustGenerate | NodeMightClobber | NodeClobbersWorld);
     467        m_flags &= ~NodeMustGenerate;
    468468        m_opInfo = local.offset();
    469469        m_opInfo2 = VirtualRegister().offset();
    … …  
    479479        children.setChild1(storage);
    480480        m_op = GetByOffset;
    481         m_flags &= ~(NodeClobbersWorld | NodeMustGenerate);
     481        m_flags &= ~NodeMustGenerate;
    482482    }
    483483   
    … …  
    488488        child1().setUseKind(CellUse);
    489489        m_op = MultiGetByOffset;
    490         m_flags &= ~NodeClobbersWorld;
    491490        ASSERT(m_flags & NodeMustGenerate);
    492491    }
    … …  
    500499        children.setChild1(storage);
    501500        m_op = PutByOffset;
    502         m_flags &= ~NodeClobbersWorld;
    503501    }
    504502   
    … …  
    508506        m_opInfo = bitwise_cast<intptr_t>(data);
    509507        m_op = MultiPutByOffset;
    510         m_flags &= ~NodeClobbersWorld;
    511508    }
    512509   

  • trunk/Source/JavaScriptCore/dfg/DFGNodeFlags.cpp

    r171613 r179840  
    7575        out.print(comma, "VarArgs");
    7676   
    77     if (flags & NodeClobbersWorld)
    78         out.print(comma, "Clobbers");
    79    
    80     if (flags & NodeMightClobber)
    81         out.print(comma, "MightClobber");
    82    
    8377    if (flags & NodeResultMask) {
    8478        if (!(flags & NodeBytecodeUsesAsNumber) && !(flags & NodeBytecodeNeedsNegZero))

  • trunk/Source/JavaScriptCore/dfg/DFGNodeFlags.h

    r174371 r179840  
    11/*
    2  * Copyright (C) 2012, 2013, 2014 Apple Inc. All rights reserved.
     2 * Copyright (C) 2012-2015 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    4747#define NodeMustGenerate                 0x0008 // set on nodes that have side effects, and may not trivially be removed by DCE.
    4848#define NodeHasVarArgs                   0x0010
    49 #define NodeClobbersWorld                0x0020
    50 #define NodeMightClobber                 0x0040
     49// 0x0020 and 0x0040 are free.
    5150                               
    5251#define NodeBehaviorMask                 0x0780

  • trunk/Source/JavaScriptCore/dfg/DFGNodeType.h

    r179536 r179840  
    11/*
    2  * Copyright (C) 2012, 2013, 2014 Apple Inc. All rights reserved.
     2 * Copyright (C) 2012-2015 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    140140    \
    141141    /* Add of values may either be arithmetic, or result in string concatenation. */\
    142     macro(ValueAdd, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
     142    macro(ValueAdd, NodeResultJS | NodeMustGenerate) \
    143143    \
    144144    /* Property access. */\
    … …  
    147147    /* this must be the directly subsequent property put. Note that PutByVal */\
    148148    /* opcodes use VarArgs beause they may have up to 4 children. */\
    149     macro(GetByVal, NodeResultJS | NodeMustGenerate | NodeMightClobber) \
    150     macro(PutByValDirect, NodeMustGenerate | NodeHasVarArgs | NodeMightClobber) \
    151     macro(PutByVal, NodeMustGenerate | NodeHasVarArgs | NodeMightClobber) \
    152     macro(PutByValAlias, NodeMustGenerate | NodeHasVarArgs | NodeMightClobber) \
    153     macro(GetById, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
    154     macro(GetByIdFlush, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
    155     macro(PutById, NodeMustGenerate | NodeClobbersWorld) \
    156     macro(PutByIdFlush, NodeMustGenerate | NodeMustGenerate | NodeClobbersWorld) \
    157     macro(PutByIdDirect, NodeMustGenerate | NodeClobbersWorld) \
     149    macro(GetByVal, NodeResultJS | NodeMustGenerate) \
     150    macro(PutByValDirect, NodeMustGenerate | NodeHasVarArgs) \
     151    macro(PutByVal, NodeMustGenerate | NodeHasVarArgs) \
     152    macro(PutByValAlias, NodeMustGenerate | NodeHasVarArgs) \
     153    macro(GetById, NodeResultJS | NodeMustGenerate) \
     154    macro(GetByIdFlush, NodeResultJS | NodeMustGenerate) \
     155    macro(PutById, NodeMustGenerate) \
     156    macro(PutByIdFlush, NodeMustGenerate | NodeMustGenerate) \
     157    macro(PutByIdDirect, NodeMustGenerate) \
    158158    macro(CheckStructure, NodeMustGenerate) \
    159159    macro(GetExecutable, NodeResultJS) \
    … …  
    194194    \
    195195    /* Optimizations for array mutation. */\
    196     macro(ArrayPush, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
    197     macro(ArrayPop, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
     196    macro(ArrayPush, NodeResultJS | NodeMustGenerate) \
     197    macro(ArrayPop, NodeResultJS | NodeMustGenerate) \
    198198    \
    199199    /* Optimizations for regular expression matching. */\
    … …  
    207207    \
    208208    /* Nodes for comparison operations. */\
    209     macro(CompareLess, NodeResultBoolean | NodeMustGenerate | NodeClobbersWorld) \
    210     macro(CompareLessEq, NodeResultBoolean | NodeMustGenerate | NodeClobbersWorld) \
    211     macro(CompareGreater, NodeResultBoolean | NodeMustGenerate | NodeClobbersWorld) \
    212     macro(CompareGreaterEq, NodeResultBoolean | NodeMustGenerate | NodeClobbersWorld) \
    213     macro(CompareEq, NodeResultBoolean | NodeMustGenerate | NodeClobbersWorld) \
     209    macro(CompareLess, NodeResultBoolean | NodeMustGenerate) \
     210    macro(CompareLessEq, NodeResultBoolean | NodeMustGenerate) \
     211    macro(CompareGreater, NodeResultBoolean | NodeMustGenerate) \
     212    macro(CompareGreaterEq, NodeResultBoolean | NodeMustGenerate) \
     213    macro(CompareEq, NodeResultBoolean | NodeMustGenerate) \
    214214    macro(CompareEqConstant, NodeResultBoolean) \
    215215    macro(CompareStrictEq, NodeResultBoolean) \
    216216    \
    217217    /* Calls. */\
    218     macro(Call, NodeResultJS | NodeMustGenerate | NodeHasVarArgs | NodeClobbersWorld) \
    219     macro(Construct, NodeResultJS | NodeMustGenerate | NodeHasVarArgs | NodeClobbersWorld) \
    220     macro(NativeCall, NodeResultJS | NodeMustGenerate | NodeHasVarArgs | NodeClobbersWorld) \
    221     macro(NativeConstruct, NodeResultJS | NodeMustGenerate | NodeHasVarArgs | NodeClobbersWorld) \
     218    macro(Call, NodeResultJS | NodeMustGenerate | NodeHasVarArgs) \
     219    macro(Construct, NodeResultJS | NodeMustGenerate | NodeHasVarArgs) \
     220    macro(NativeCall, NodeResultJS | NodeMustGenerate | NodeHasVarArgs) \
     221    macro(NativeConstruct, NodeResultJS | NodeMustGenerate | NodeHasVarArgs) \
    222222    \
    223223    /* Allocations. */\
    … …  
    226226    macro(NewArrayWithSize, NodeResultJS | NodeMustGenerate) \
    227227    macro(NewArrayBuffer, NodeResultJS) \
    228     macro(NewTypedArray, NodeResultJS | NodeClobbersWorld | NodeMustGenerate) \
     228    macro(NewTypedArray, NodeResultJS | NodeMustGenerate) \
    229229    macro(NewRegexp, NodeResultJS) \
    230230    \
    … …  
    250250    macro(TypeOf, NodeResultJS) \
    251251    macro(LogicalNot, NodeResultBoolean) \
    252     macro(ToPrimitive, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
    253     macro(ToString, NodeResultJS | NodeMustGenerate | NodeMightClobber) \
     252    macro(ToPrimitive, NodeResultJS | NodeMustGenerate) \
     253    macro(ToString, NodeResultJS | NodeMustGenerate) \
    254254    macro(NewStringObject, NodeResultJS) \
    255255    macro(MakeRope, NodeResultJS) \
    256     macro(In, NodeResultBoolean | NodeMustGenerate | NodeClobbersWorld) \
     256    macro(In, NodeResultBoolean | NodeMustGenerate) \
    257257    macro(ProfileType, NodeMustGenerate) \
    258258    macro(ProfileControlFlow, NodeMustGenerate) \
    … …  
    270270    macro(GetMyArgumentsLength, NodeResultJS | NodeMustGenerate) \
    271271    macro(GetMyArgumentByVal, NodeResultJS | NodeMustGenerate) \
    272     macro(GetMyArgumentsLengthSafe, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
    273     macro(GetMyArgumentByValSafe, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
     272    macro(GetMyArgumentsLengthSafe, NodeResultJS | NodeMustGenerate) \
     273    macro(GetMyArgumentByValSafe, NodeResultJS | NodeMustGenerate) \
    274274    macro(CheckArgumentsNotCreated, NodeMustGenerate) \
    275275    \
Note: See TracChangeset for help on using the changeset viewer.