| /* |
| * Copyright (C) 2013-2020 Apple Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "DFGNode.h" |
| |
| #if ENABLE(DFG_JIT) |
| |
| #include "DFGGraph.h" |
| #include "DFGPromotedHeapLocation.h" |
| #include "DOMJITSignature.h" |
| #include "JSImmutableButterfly.h" |
| |
| namespace JSC { namespace DFG { |
| |
| const char Node::HashSetTemplateInstantiationString[] = "::JSC::DFG::Node*"; |
| |
| DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(DFGNode); |
| |
| bool MultiPutByOffsetData::writesStructures() const |
| { |
| for (unsigned i = variants.size(); i--;) { |
| if (variants[i].writesStructures()) |
| return true; |
| } |
| return false; |
| } |
| |
| bool MultiPutByOffsetData::reallocatesStorage() const |
| { |
| for (unsigned i = variants.size(); i--;) { |
| if (variants[i].reallocatesStorage()) |
| return true; |
| } |
| return false; |
| } |
| |
| bool MultiDeleteByOffsetData::writesStructures() const |
| { |
| for (unsigned i = variants.size(); i--;) { |
| if (variants[i].writesStructures()) |
| return true; |
| } |
| return false; |
| } |
| |
| bool MultiDeleteByOffsetData::allVariantsStoreEmpty() const |
| { |
| for (unsigned i = variants.size(); i--;) { |
| if (!variants[i].newStructure()) |
| return false; |
| } |
| return true; |
| } |
| |
| void BranchTarget::dump(PrintStream& out) const |
| { |
| if (!block) |
| return; |
| |
| out.print(*block); |
| |
| if (count == count) // If the count is not NaN, then print it. |
| out.print("/w:", count); |
| } |
| |
| bool Node::hasVariableAccessData(Graph& graph) |
| { |
| switch (op()) { |
| case Phi: |
| return graph.m_form != SSA; |
| case GetLocal: |
| case SetLocal: |
| case SetArgumentDefinitely: |
| case SetArgumentMaybe: |
| case Flush: |
| case PhantomLocal: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| void Node::remove(Graph& graph) |
| { |
| switch (op()) { |
| case MultiGetByOffset: { |
| MultiGetByOffsetData& data = multiGetByOffsetData(); |
| StructureSet set; |
| for (MultiGetByOffsetCase& getCase : data.cases) { |
| getCase.set().forEach( |
| [&] (RegisteredStructure structure) { |
| set.add(structure.get()); |
| }); |
| } |
| convertToCheckStructure(graph.addStructureSet(set)); |
| return; |
| } |
| |
| case MatchStructure: { |
| MatchStructureData& data = matchStructureData(); |
| RegisteredStructureSet set; |
| for (MatchStructureVariant& variant : data.variants) |
| set.add(variant.structure); |
| convertToCheckStructure(graph.addStructureSet(set)); |
| return; |
| } |
| |
| default: |
| if (flags() & NodeHasVarArgs) { |
| unsigned targetIndex = 0; |
| for (unsigned i = 0; i < numChildren(); ++i) { |
| Edge& edge = graph.varArgChild(this, i); |
| if (!edge) |
| continue; |
| if (edge.willHaveCheck()) { |
| Edge& dst = graph.varArgChild(this, targetIndex++); |
| std::swap(dst, edge); |
| continue; |
| } |
| edge = Edge(); |
| } |
| setOpAndDefaultFlags(CheckVarargs); |
| children.setNumChildren(targetIndex); |
| } else { |
| children = children.justChecks(); |
| setOpAndDefaultFlags(Check); |
| } |
| return; |
| } |
| } |
| |
| void Node::removeWithoutChecks() |
| { |
| children = AdjacencyList(); |
| setOpAndDefaultFlags(Check); |
| } |
| |
| void Node::replaceWith(Graph& graph, Node* other) |
| { |
| remove(graph); |
| setReplacement(other); |
| } |
| |
| void Node::replaceWithWithoutChecks(Node* other) |
| { |
| removeWithoutChecks(); |
| setReplacement(other); |
| } |
| |
| void Node::convertToIdentity() |
| { |
| RELEASE_ASSERT(child1()); |
| RELEASE_ASSERT(!child2()); |
| NodeFlags result = canonicalResultRepresentation(this->result()); |
| setOpAndDefaultFlags(Identity); |
| setResult(result); |
| } |
| |
| void Node::convertToIdentityOn(Node* child) |
| { |
| children.reset(); |
| clearFlags(NodeHasVarArgs); |
| child1() = child->defaultEdge(); |
| NodeFlags output = canonicalResultRepresentation(this->result()); |
| NodeFlags input = canonicalResultRepresentation(child->result()); |
| if (output == input) { |
| setOpAndDefaultFlags(Identity); |
| setResult(output); |
| return; |
| } |
| switch (output) { |
| case NodeResultDouble: |
| setOpAndDefaultFlags(DoubleRep); |
| switch (input) { |
| case NodeResultInt52: |
| child1().setUseKind(Int52RepUse); |
| return; |
| case NodeResultJS: |
| child1().setUseKind(NumberUse); |
| return; |
| default: |
| RELEASE_ASSERT_NOT_REACHED(); |
| return; |
| } |
| case NodeResultInt52: |
| setOpAndDefaultFlags(Int52Rep); |
| switch (input) { |
| case NodeResultDouble: |
| child1().setUseKind(DoubleRepAnyIntUse); |
| return; |
| case NodeResultJS: |
| child1().setUseKind(AnyIntUse); |
| return; |
| default: |
| RELEASE_ASSERT_NOT_REACHED(); |
| return; |
| } |
| case NodeResultJS: |
| setOpAndDefaultFlags(ValueRep); |
| switch (input) { |
| case NodeResultDouble: |
| child1().setUseKind(DoubleRepUse); |
| return; |
| case NodeResultInt52: |
| child1().setUseKind(Int52RepUse); |
| return; |
| default: |
| RELEASE_ASSERT_NOT_REACHED(); |
| return; |
| } |
| default: |
| RELEASE_ASSERT_NOT_REACHED(); |
| return; |
| } |
| } |
| |
| void Node::convertToLazyJSConstant(Graph& graph, LazyJSValue value) |
| { |
| m_op = LazyJSConstant; |
| m_flags &= ~NodeMustGenerate; |
| m_opInfo = graph.m_lazyJSValues.add(value); |
| children.reset(); |
| } |
| |
| void Node::convertToNewArrayBuffer(FrozenValue* immutableButterfly) |
| { |
| setOpAndDefaultFlags(NewArrayBuffer); |
| NewArrayBufferData data { }; |
| data.indexingMode = immutableButterfly->cast<JSImmutableButterfly*>()->indexingMode(); |
| data.vectorLengthHint = immutableButterfly->cast<JSImmutableButterfly*>()->toButterfly()->vectorLength(); |
| children.reset(); |
| m_opInfo = immutableButterfly; |
| m_opInfo2 = data.asQuadWord; |
| } |
| |
| void Node::convertToDirectCall(FrozenValue* executable) |
| { |
| NodeType newOp = LastNodeType; |
| switch (op()) { |
| case Call: |
| newOp = DirectCall; |
| break; |
| case Construct: |
| newOp = DirectConstruct; |
| break; |
| case TailCallInlinedCaller: |
| newOp = DirectTailCallInlinedCaller; |
| break; |
| case TailCall: |
| newOp = DirectTailCall; |
| break; |
| default: |
| RELEASE_ASSERT_NOT_REACHED(); |
| break; |
| } |
| |
| m_op = newOp; |
| m_opInfo = executable; |
| } |
| |
| void Node::convertToCallDOM(Graph& graph) |
| { |
| ASSERT(op() == Call); |
| ASSERT(signature()); |
| |
| Edge edges[3]; |
| // Skip the first one. This is callee. |
| RELEASE_ASSERT(numChildren() <= 4); |
| for (unsigned i = 1; i < numChildren(); ++i) |
| edges[i - 1] = graph.varArgChild(this, i); |
| |
| setOpAndDefaultFlags(CallDOM); |
| children.setChild1(edges[0]); |
| children.setChild2(edges[1]); |
| children.setChild3(edges[2]); |
| |
| if (!signature()->effect.mustGenerate()) |
| clearFlags(NodeMustGenerate); |
| } |
| |
| void Node::convertToRegExpExecNonGlobalOrStickyWithoutChecks(FrozenValue* regExp) |
| { |
| ASSERT(op() == RegExpExec); |
| setOpAndDefaultFlags(RegExpExecNonGlobalOrSticky); |
| children.child1() = Edge(children.child1().node(), KnownCellUse); |
| children.child2() = Edge(children.child3().node(), KnownStringUse); |
| children.child3() = Edge(); |
| m_opInfo = regExp; |
| } |
| |
| void Node::convertToRegExpMatchFastGlobalWithoutChecks(FrozenValue* regExp) |
| { |
| ASSERT(op() == RegExpMatchFast); |
| setOpAndDefaultFlags(RegExpMatchFastGlobal); |
| children.child1() = Edge(children.child1().node(), KnownCellUse); |
| children.child2() = Edge(children.child3().node(), KnownStringUse); |
| children.child3() = Edge(); |
| m_opInfo = regExp; |
| } |
| |
| String Node::tryGetString(Graph& graph) |
| { |
| if (hasConstant()) |
| return constant()->tryGetString(graph); |
| if (hasLazyJSValue()) |
| return lazyJSValue().tryGetString(graph); |
| return String(); |
| } |
| |
| PromotedLocationDescriptor Node::promotedLocationDescriptor() |
| { |
| return PromotedLocationDescriptor(static_cast<PromotedLocationKind>(m_opInfo.as<uint32_t>()), m_opInfo2.as<uint32_t>()); |
| } |
| |
| } } // namespace JSC::DFG |
| |
| namespace WTF { |
| |
| using namespace JSC; |
| using namespace JSC::DFG; |
| |
| void printInternal(PrintStream& out, SwitchKind kind) |
| { |
| switch (kind) { |
| case SwitchImm: |
| out.print("SwitchImm"); |
| return; |
| case SwitchChar: |
| out.print("SwitchChar"); |
| return; |
| case SwitchString: |
| out.print("SwitchString"); |
| return; |
| case SwitchCell: |
| out.print("SwitchCell"); |
| return; |
| } |
| RELEASE_ASSERT_NOT_REACHED(); |
| } |
| |
| void printInternal(PrintStream& out, Node* node) |
| { |
| if (!node) { |
| out.print("-"); |
| return; |
| } |
| out.print("D@", node->index()); |
| if (node->hasDoubleResult()) |
| out.print("<Double>"); |
| else if (node->hasInt52Result()) |
| out.print("<Int52>"); |
| } |
| |
| } // namespace WTF |
| |
| #endif // ENABLE(DFG_JIT) |
| |
