Diff
Modified: trunk/Source/_javascript_Core/ChangeLog (179839 => 179840)
--- trunk/Source/_javascript_Core/ChangeLog 2015-02-09 19:53:28 UTC (rev 179839)
+++ trunk/Source/_javascript_Core/ChangeLog 2015-02-09 19:57:41 UTC (rev 179840)
@@ -1,3 +1,53 @@
+2015-02-08 Filip Pizlo <[email protected]>
+
+ 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:
+
2015-02-09 Csaba Osztrogonác <[email protected]>
Fix the !ENABLE(DFG_JIT) build
Modified: trunk/Source/_javascript_Core/dfg/DFGClobberize.cpp (179839 => 179840)
--- trunk/Source/_javascript_Core/dfg/DFGClobberize.cpp 2015-02-09 19:53:28 UTC (rev 179839)
+++ trunk/Source/_javascript_Core/dfg/DFGClobberize.cpp 2015-02-09 19:57:41 UTC (rev 179840)
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2013, 2014 Apple Inc. All rights reserved.
+ * Copyright (C) 2013-2015 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@@ -56,6 +56,19 @@
return addWrite.result();
}
+bool clobbersWorld(Graph& graph, Node* node)
+{
+ bool result = false;
+ clobberize(
+ graph, node, NoOpClobberize(),
+ [&] (AbstractHeap heap) {
+ if (heap == AbstractHeap(World))
+ result = true;
+ },
+ NoOpClobberize());
+ return result;
+}
+
} } // namespace JSC::DFG
#endif // ENABLE(DFG_JIT)
Modified: trunk/Source/_javascript_Core/dfg/DFGClobberize.h (179839 => 179840)
--- trunk/Source/_javascript_Core/dfg/DFGClobberize.h 2015-02-09 19:53:28 UTC (rev 179839)
+++ trunk/Source/_javascript_Core/dfg/DFGClobberize.h 2015-02-09 19:57:41 UTC (rev 179840)
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2013, 2014 Apple Inc. All rights reserved.
+ * Copyright (C) 2013-2015 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@@ -934,6 +934,8 @@
bool accessesOverlap(Graph&, Node*, AbstractHeap);
bool writesOverlap(Graph&, Node*, AbstractHeap);
+bool clobbersWorld(Graph&, Node*);
+
// We would have used bind() for these, but because of the overlaoding that we are doing,
// it's quite a bit of clearer to just write this out the traditional way.
Modified: trunk/Source/_javascript_Core/dfg/DFGDoesGC.cpp (179839 => 179840)
--- trunk/Source/_javascript_Core/dfg/DFGDoesGC.cpp 2015-02-09 19:53:28 UTC (rev 179839)
+++ trunk/Source/_javascript_Core/dfg/DFGDoesGC.cpp 2015-02-09 19:57:41 UTC (rev 179840)
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2014 Apple Inc. All rights reserved.
+ * Copyright (C) 2014, 2015 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@@ -28,6 +28,7 @@
#if ENABLE(DFG_JIT)
+#include "DFGClobberize.h"
#include "DFGGraph.h"
#include "DFGNode.h"
#include "Operations.h"
@@ -36,7 +37,7 @@
bool doesGC(Graph& graph, Node* node)
{
- if (graph.clobbersWorld(node))
+ if (clobbersWorld(graph, node))
return true;
// Now consider nodes that don't clobber the world but that still may GC. This includes all
Modified: trunk/Source/_javascript_Core/dfg/DFGFixupPhase.cpp (179839 => 179840)
--- trunk/Source/_javascript_Core/dfg/DFGFixupPhase.cpp 2015-02-09 19:53:28 UTC (rev 179839)
+++ trunk/Source/_javascript_Core/dfg/DFGFixupPhase.cpp 2015-02-09 19:57:41 UTC (rev 179840)
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2012, 2013, 2014 Apple Inc. All rights reserved.
+ * Copyright (C) 2012-2015 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@@ -161,14 +161,14 @@
case ValueAdd: {
if (attemptToMakeIntegerAdd(node)) {
node->setOp(ArithAdd);
- node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
+ node->clearFlags(NodeMustGenerate);
break;
}
if (Node::shouldSpeculateNumberOrBooleanExpectingDefined(node->child1().node(), node->child2().node())) {
fixDoubleOrBooleanEdge(node->child1());
fixDoubleOrBooleanEdge(node->child2());
node->setOp(ArithAdd);
- node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
+ node->clearFlags(NodeMustGenerate);
node->setResult(NodeResultDouble);
break;
}
@@ -382,26 +382,26 @@
&& Node::shouldSpeculateBoolean(node->child1().node(), node->child2().node())) {
fixEdge<BooleanUse>(node->child1());
fixEdge<BooleanUse>(node->child2());
- node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
+ node->clearFlags(NodeMustGenerate);
break;
}
if (Node::shouldSpeculateInt32OrBoolean(node->child1().node(), node->child2().node())) {
fixIntOrBooleanEdge(node->child1());
fixIntOrBooleanEdge(node->child2());
- node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
+ node->clearFlags(NodeMustGenerate);
break;
}
if (enableInt52()
&& Node::shouldSpeculateMachineInt(node->child1().node(), node->child2().node())) {
fixEdge<Int52RepUse>(node->child1());
fixEdge<Int52RepUse>(node->child2());
- node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
+ node->clearFlags(NodeMustGenerate);
break;
}
if (Node::shouldSpeculateNumberOrBoolean(node->child1().node(), node->child2().node())) {
fixDoubleOrBooleanEdge(node->child1());
fixDoubleOrBooleanEdge(node->child2());
- node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
+ node->clearFlags(NodeMustGenerate);
break;
}
if (node->op() != CompareEq)
@@ -409,31 +409,31 @@
if (node->child1()->shouldSpeculateStringIdent() && node->child2()->shouldSpeculateStringIdent()) {
fixEdge<StringIdentUse>(node->child1());
fixEdge<StringIdentUse>(node->child2());
- node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
+ node->clearFlags(NodeMustGenerate);
break;
}
if (node->child1()->shouldSpeculateString() && node->child2()->shouldSpeculateString() && GPRInfo::numberOfRegisters >= 7) {
fixEdge<StringUse>(node->child1());
fixEdge<StringUse>(node->child2());
- node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
+ node->clearFlags(NodeMustGenerate);
break;
}
if (node->child1()->shouldSpeculateObject() && node->child2()->shouldSpeculateObject()) {
fixEdge<ObjectUse>(node->child1());
fixEdge<ObjectUse>(node->child2());
- node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
+ node->clearFlags(NodeMustGenerate);
break;
}
if (node->child1()->shouldSpeculateObject() && node->child2()->shouldSpeculateObjectOrOther()) {
fixEdge<ObjectUse>(node->child1());
fixEdge<ObjectOrOtherUse>(node->child2());
- node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
+ node->clearFlags(NodeMustGenerate);
break;
}
if (node->child1()->shouldSpeculateObjectOrOther() && node->child2()->shouldSpeculateObject()) {
fixEdge<ObjectOrOtherUse>(node->child1());
fixEdge<ObjectUse>(node->child2());
- node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
+ node->clearFlags(NodeMustGenerate);
break;
}
break;
@@ -829,7 +829,7 @@
case NewTypedArray: {
if (node->child1()->shouldSpeculateInt32()) {
fixEdge<Int32Use>(node->child1());
- node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
+ node->clearFlags(NodeMustGenerate);
break;
}
break;
@@ -1947,7 +1947,7 @@
// We can use a BitLShift here because typed arrays will never have a byteLength
// that overflows int32.
node->setOp(BitLShift);
- node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
+ node->clearFlags(NodeMustGenerate);
observeUseKindOnNode(length, Int32Use);
observeUseKindOnNode(shiftAmount, Int32Use);
node->child1() = Edge(length, Int32Use);
@@ -1958,7 +1958,7 @@
void convertToGetArrayLength(Node* node, ArrayMode arrayMode)
{
node->setOp(GetArrayLength);
- node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
+ node->clearFlags(NodeMustGenerate);
fixEdge<KnownCellUse>(node->child1());
node->setArrayMode(arrayMode);
@@ -1991,7 +1991,7 @@
0, neverNeedsStorage);
node->setOp(GetTypedArrayByteOffset);
- node->clearFlags(NodeMustGenerate | NodeClobbersWorld);
+ node->clearFlags(NodeMustGenerate);
fixEdge<KnownCellUse>(node->child1());
return true;
}
Modified: trunk/Source/_javascript_Core/dfg/DFGGraph.h (179839 => 179840)
--- trunk/Source/_javascript_Core/dfg/DFGGraph.h 2015-02-09 19:53:28 UTC (rev 179839)
+++ trunk/Source/_javascript_Core/dfg/DFGGraph.h 2015-02-09 19:57:41 UTC (rev 179840)
@@ -545,72 +545,6 @@
void killUnreachableBlocks();
- bool isPredictedNumerical(Node* node)
- {
- return isNumerical(node->child1().useKind()) && isNumerical(node->child2().useKind());
- }
-
- // Note that a 'true' return does not actually mean that the ByVal access clobbers nothing.
- // It really means that it will not clobber the entire world. It's still up to you to
- // carefully consider things like:
- // - PutByVal definitely changes the array it stores to, and may even change its length.
- // - PutByOffset definitely changes the object it stores to.
- // - and so on.
- bool byValIsPure(Node* node)
- {
- switch (node->arrayMode().type()) {
- case Array::Generic:
- return false;
- case Array::Int32:
- case Array::Double:
- case Array::Contiguous:
- case Array::ArrayStorage:
- return !node->arrayMode().isOutOfBounds();
- case Array::SlowPutArrayStorage:
- return !node->arrayMode().mayStoreToHole();
- case Array::String:
- return node->op() == GetByVal && node->arrayMode().isInBounds();
-#if USE(JSVALUE32_64)
- case Array::Arguments:
- if (node->op() == GetByVal)
- return true;
- return false;
-#endif // USE(JSVALUE32_64)
- default:
- return true;
- }
- }
-
- bool clobbersWorld(Node* node)
- {
- if (node->flags() & NodeClobbersWorld)
- return true;
- if (!(node->flags() & NodeMightClobber))
- return false;
- switch (node->op()) {
- case GetByVal:
- case PutByValDirect:
- case PutByVal:
- case PutByValAlias:
- return !byValIsPure(node);
- case ToString:
- switch (node->child1().useKind()) {
- case StringObjectUse:
- case StringOrStringObjectUse:
- return false;
- case CellUse:
- case UntypedUse:
- return true;
- default:
- RELEASE_ASSERT_NOT_REACHED();
- return true;
- }
- default:
- RELEASE_ASSERT_NOT_REACHED();
- return true; // If by some oddity we hit this case in release build it's safer to have CSE assume the worst.
- }
- }
-
void determineReachability();
void resetReachability();
Modified: trunk/Source/_javascript_Core/dfg/DFGNode.h (179839 => 179840)
--- trunk/Source/_javascript_Core/dfg/DFGNode.h 2015-02-09 19:53:28 UTC (rev 179839)
+++ trunk/Source/_javascript_Core/dfg/DFGNode.h 2015-02-09 19:57:41 UTC (rev 179840)
@@ -448,7 +448,7 @@
m_op = Int52Constant;
else
m_op = JSConstant;
- m_flags &= ~(NodeMustGenerate | NodeMightClobber | NodeClobbersWorld);
+ m_flags &= ~NodeMustGenerate;
m_opInfo = bitwise_cast<uintptr_t>(value);
children.reset();
}
@@ -464,7 +464,7 @@
void convertToGetLocalUnlinked(VirtualRegister local)
{
m_op = GetLocalUnlinked;
- m_flags &= ~(NodeMustGenerate | NodeMightClobber | NodeClobbersWorld);
+ m_flags &= ~NodeMustGenerate;
m_opInfo = local.offset();
m_opInfo2 = VirtualRegister().offset();
children.reset();
@@ -478,7 +478,7 @@
children.child2().setUseKind(KnownCellUse);
children.setChild1(storage);
m_op = GetByOffset;
- m_flags &= ~(NodeClobbersWorld | NodeMustGenerate);
+ m_flags &= ~NodeMustGenerate;
}
void convertToMultiGetByOffset(MultiGetByOffsetData* data)
@@ -487,7 +487,6 @@
m_opInfo = bitwise_cast<intptr_t>(data);
child1().setUseKind(CellUse);
m_op = MultiGetByOffset;
- m_flags &= ~NodeClobbersWorld;
ASSERT(m_flags & NodeMustGenerate);
}
@@ -499,7 +498,6 @@
children.setChild2(children.child1());
children.setChild1(storage);
m_op = PutByOffset;
- m_flags &= ~NodeClobbersWorld;
}
void convertToMultiPutByOffset(MultiPutByOffsetData* data)
@@ -507,7 +505,6 @@
ASSERT(m_op == PutById || m_op == PutByIdDirect || m_op == PutByIdFlush);
m_opInfo = bitwise_cast<intptr_t>(data);
m_op = MultiPutByOffset;
- m_flags &= ~NodeClobbersWorld;
}
void convertToPutByOffsetHint()
Modified: trunk/Source/_javascript_Core/dfg/DFGNodeFlags.cpp (179839 => 179840)
--- trunk/Source/_javascript_Core/dfg/DFGNodeFlags.cpp 2015-02-09 19:53:28 UTC (rev 179839)
+++ trunk/Source/_javascript_Core/dfg/DFGNodeFlags.cpp 2015-02-09 19:57:41 UTC (rev 179840)
@@ -74,12 +74,6 @@
if (flags & NodeHasVarArgs)
out.print(comma, "VarArgs");
- if (flags & NodeClobbersWorld)
- out.print(comma, "Clobbers");
-
- if (flags & NodeMightClobber)
- out.print(comma, "MightClobber");
-
if (flags & NodeResultMask) {
if (!(flags & NodeBytecodeUsesAsNumber) && !(flags & NodeBytecodeNeedsNegZero))
out.print(comma, "PureInt");
Modified: trunk/Source/_javascript_Core/dfg/DFGNodeFlags.h (179839 => 179840)
--- trunk/Source/_javascript_Core/dfg/DFGNodeFlags.h 2015-02-09 19:53:28 UTC (rev 179839)
+++ trunk/Source/_javascript_Core/dfg/DFGNodeFlags.h 2015-02-09 19:57:41 UTC (rev 179840)
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2012, 2013, 2014 Apple Inc. All rights reserved.
+ * Copyright (C) 2012-2015 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@@ -46,8 +46,7 @@
#define NodeMustGenerate 0x0008 // set on nodes that have side effects, and may not trivially be removed by DCE.
#define NodeHasVarArgs 0x0010
-#define NodeClobbersWorld 0x0020
-#define NodeMightClobber 0x0040
+// 0x0020 and 0x0040 are free.
#define NodeBehaviorMask 0x0780
#define NodeMayOverflowInBaseline 0x0080
Modified: trunk/Source/_javascript_Core/dfg/DFGNodeType.h (179839 => 179840)
--- trunk/Source/_javascript_Core/dfg/DFGNodeType.h 2015-02-09 19:53:28 UTC (rev 179839)
+++ trunk/Source/_javascript_Core/dfg/DFGNodeType.h 2015-02-09 19:57:41 UTC (rev 179840)
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2012, 2013, 2014 Apple Inc. All rights reserved.
+ * Copyright (C) 2012-2015 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@@ -139,22 +139,22 @@
macro(ArithCos, NodeResultNumber) \
\
/* Add of values may either be arithmetic, or result in string concatenation. */\
- macro(ValueAdd, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
+ macro(ValueAdd, NodeResultJS | NodeMustGenerate) \
\
/* Property access. */\
/* PutByValAlias indicates a 'put' aliases a prior write to the same property. */\
/* Since a put to 'length' may invalidate optimizations here, */\
/* this must be the directly subsequent property put. Note that PutByVal */\
/* opcodes use VarArgs beause they may have up to 4 children. */\
- macro(GetByVal, NodeResultJS | NodeMustGenerate | NodeMightClobber) \
- macro(PutByValDirect, NodeMustGenerate | NodeHasVarArgs | NodeMightClobber) \
- macro(PutByVal, NodeMustGenerate | NodeHasVarArgs | NodeMightClobber) \
- macro(PutByValAlias, NodeMustGenerate | NodeHasVarArgs | NodeMightClobber) \
- macro(GetById, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
- macro(GetByIdFlush, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
- macro(PutById, NodeMustGenerate | NodeClobbersWorld) \
- macro(PutByIdFlush, NodeMustGenerate | NodeMustGenerate | NodeClobbersWorld) \
- macro(PutByIdDirect, NodeMustGenerate | NodeClobbersWorld) \
+ macro(GetByVal, NodeResultJS | NodeMustGenerate) \
+ macro(PutByValDirect, NodeMustGenerate | NodeHasVarArgs) \
+ macro(PutByVal, NodeMustGenerate | NodeHasVarArgs) \
+ macro(PutByValAlias, NodeMustGenerate | NodeHasVarArgs) \
+ macro(GetById, NodeResultJS | NodeMustGenerate) \
+ macro(GetByIdFlush, NodeResultJS | NodeMustGenerate) \
+ macro(PutById, NodeMustGenerate) \
+ macro(PutByIdFlush, NodeMustGenerate | NodeMustGenerate) \
+ macro(PutByIdDirect, NodeMustGenerate) \
macro(CheckStructure, NodeMustGenerate) \
macro(GetExecutable, NodeResultJS) \
macro(PutStructure, NodeMustGenerate) \
@@ -193,8 +193,8 @@
macro(CheckInBounds, NodeMustGenerate) \
\
/* Optimizations for array mutation. */\
- macro(ArrayPush, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
- macro(ArrayPop, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
+ macro(ArrayPush, NodeResultJS | NodeMustGenerate) \
+ macro(ArrayPop, NodeResultJS | NodeMustGenerate) \
\
/* Optimizations for regular _expression_ matching. */\
macro(RegExpExec, NodeResultJS | NodeMustGenerate) \
@@ -206,26 +206,26 @@
macro(StringFromCharCode, NodeResultJS) \
\
/* Nodes for comparison operations. */\
- macro(CompareLess, NodeResultBoolean | NodeMustGenerate | NodeClobbersWorld) \
- macro(CompareLessEq, NodeResultBoolean | NodeMustGenerate | NodeClobbersWorld) \
- macro(CompareGreater, NodeResultBoolean | NodeMustGenerate | NodeClobbersWorld) \
- macro(CompareGreaterEq, NodeResultBoolean | NodeMustGenerate | NodeClobbersWorld) \
- macro(CompareEq, NodeResultBoolean | NodeMustGenerate | NodeClobbersWorld) \
+ macro(CompareLess, NodeResultBoolean | NodeMustGenerate) \
+ macro(CompareLessEq, NodeResultBoolean | NodeMustGenerate) \
+ macro(CompareGreater, NodeResultBoolean | NodeMustGenerate) \
+ macro(CompareGreaterEq, NodeResultBoolean | NodeMustGenerate) \
+ macro(CompareEq, NodeResultBoolean | NodeMustGenerate) \
macro(CompareEqConstant, NodeResultBoolean) \
macro(CompareStrictEq, NodeResultBoolean) \
\
/* Calls. */\
- macro(Call, NodeResultJS | NodeMustGenerate | NodeHasVarArgs | NodeClobbersWorld) \
- macro(Construct, NodeResultJS | NodeMustGenerate | NodeHasVarArgs | NodeClobbersWorld) \
- macro(NativeCall, NodeResultJS | NodeMustGenerate | NodeHasVarArgs | NodeClobbersWorld) \
- macro(NativeConstruct, NodeResultJS | NodeMustGenerate | NodeHasVarArgs | NodeClobbersWorld) \
+ macro(Call, NodeResultJS | NodeMustGenerate | NodeHasVarArgs) \
+ macro(Construct, NodeResultJS | NodeMustGenerate | NodeHasVarArgs) \
+ macro(NativeCall, NodeResultJS | NodeMustGenerate | NodeHasVarArgs) \
+ macro(NativeConstruct, NodeResultJS | NodeMustGenerate | NodeHasVarArgs) \
\
/* Allocations. */\
macro(NewObject, NodeResultJS) \
macro(NewArray, NodeResultJS | NodeHasVarArgs) \
macro(NewArrayWithSize, NodeResultJS | NodeMustGenerate) \
macro(NewArrayBuffer, NodeResultJS) \
- macro(NewTypedArray, NodeResultJS | NodeClobbersWorld | NodeMustGenerate) \
+ macro(NewTypedArray, NodeResultJS | NodeMustGenerate) \
macro(NewRegexp, NodeResultJS) \
\
/* Support for allocation sinking. */\
@@ -249,11 +249,11 @@
macro(IsFunction, NodeResultBoolean) \
macro(TypeOf, NodeResultJS) \
macro(LogicalNot, NodeResultBoolean) \
- macro(ToPrimitive, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
- macro(ToString, NodeResultJS | NodeMustGenerate | NodeMightClobber) \
+ macro(ToPrimitive, NodeResultJS | NodeMustGenerate) \
+ macro(ToString, NodeResultJS | NodeMustGenerate) \
macro(NewStringObject, NodeResultJS) \
macro(MakeRope, NodeResultJS) \
- macro(In, NodeResultBoolean | NodeMustGenerate | NodeClobbersWorld) \
+ macro(In, NodeResultBoolean | NodeMustGenerate) \
macro(ProfileType, NodeMustGenerate) \
macro(ProfileControlFlow, NodeMustGenerate) \
\
@@ -269,8 +269,8 @@
macro(TearOffArguments, NodeMustGenerate) \
macro(GetMyArgumentsLength, NodeResultJS | NodeMustGenerate) \
macro(GetMyArgumentByVal, NodeResultJS | NodeMustGenerate) \
- macro(GetMyArgumentsLengthSafe, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
- macro(GetMyArgumentByValSafe, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
+ macro(GetMyArgumentsLengthSafe, NodeResultJS | NodeMustGenerate) \
+ macro(GetMyArgumentByValSafe, NodeResultJS | NodeMustGenerate) \
macro(CheckArgumentsNotCreated, NodeMustGenerate) \
\
/* Nodes for creating functions. */\
