1/* 2 * Copyright (C) 2011, 2013 Apple Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY 14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR 17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY 21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 */ 25 26#ifndef DFGBasicBlock_h 27#define DFGBasicBlock_h 28 29#if ENABLE(DFG_JIT) 30 31#include "DFGAbstractValue.h" 32#include "DFGBranchDirection.h" 33#include "DFGNode.h" 34#include "DFGVariadicFunction.h" 35#include "Operands.h" 36#include <wtf/OwnPtr.h> 37#include <wtf/Vector.h> 38 39namespace JSC { namespace DFG { 40 41class Graph; 42 43typedef Vector <BlockIndex, 2> PredecessorList; 44 45struct BasicBlock : Vector<Node*, 8> { 46 BasicBlock(unsigned bytecodeBegin, unsigned numArguments, unsigned numLocals) 47 : bytecodeBegin(bytecodeBegin) 48 , isOSRTarget(false) 49 , cfaHasVisited(false) 50 , cfaShouldRevisit(false) 51 , cfaFoundConstants(false) 52 , cfaDidFinish(true) 53 , cfaBranchDirection(InvalidBranchDirection) 54#if !ASSERT_DISABLED 55 , isLinked(false) 56#endif 57 , isReachable(false) 58 , variablesAtHead(numArguments, numLocals) 59 , variablesAtTail(numArguments, numLocals) 60 , valuesAtHead(numArguments, numLocals) 61 , valuesAtTail(numArguments, numLocals) 62 { 63 } 64 65 ~BasicBlock() 66 { 67 } 68 69 void ensureLocals(unsigned newNumLocals) 70 { 71 variablesAtHead.ensureLocals(newNumLocals); 72 variablesAtTail.ensureLocals(newNumLocals); 73 valuesAtHead.ensureLocals(newNumLocals); 74 valuesAtTail.ensureLocals(newNumLocals); 75 } 76 77 size_t numNodes() const { return phis.size() + size(); } 78 Node* node(size_t i) const 79 { 80 if (i < phis.size()) 81 return phis[i]; 82 return at(i - phis.size()); 83 } 84 bool isPhiIndex(size_t i) const { return i < phis.size(); } 85 86 bool isInPhis(Node* node) const 87 { 88 for (size_t i = 0; i < phis.size(); ++i) { 89 if (phis[i] == node) 90 return true; 91 } 92 return false; 93 } 94 95 bool isInBlock(Node* myNode) const 96 { 97 for (size_t i = 0; i < numNodes(); ++i) { 98 if (node(i) == myNode) 99 return true; 100 } 101 return false; 102 } 103 104#define DFG_DEFINE_APPEND_NODE(templatePre, templatePost, typeParams, valueParamsComma, valueParams, valueArgs) \ 105 templatePre typeParams templatePost Node* appendNode(Graph&, SpeculatedType valueParamsComma valueParams); 106 DFG_VARIADIC_TEMPLATE_FUNCTION(DFG_DEFINE_APPEND_NODE) 107#undef DFG_DEFINE_APPEND_NODE 108 109 // This value is used internally for block linking and OSR entry. It is mostly meaningless 110 // for other purposes due to inlining. 111 unsigned bytecodeBegin; 112 113 bool isOSRTarget; 114 bool cfaHasVisited; 115 bool cfaShouldRevisit; 116 bool cfaFoundConstants; 117 bool cfaDidFinish; 118 BranchDirection cfaBranchDirection; 119#if !ASSERT_DISABLED 120 bool isLinked; 121#endif 122 bool isReachable; 123 124 Vector<Node*> phis; 125 PredecessorList m_predecessors; 126 127 Operands<Node*, NodePointerTraits> variablesAtHead; 128 Operands<Node*, NodePointerTraits> variablesAtTail; 129 130 Operands<AbstractValue> valuesAtHead; 131 Operands<AbstractValue> valuesAtTail; 132}; 133 134struct UnlinkedBlock { 135 BlockIndex m_blockIndex; 136 bool m_needsNormalLinking; 137 bool m_needsEarlyReturnLinking; 138 139 UnlinkedBlock() { } 140 141 explicit UnlinkedBlock(BlockIndex blockIndex) 142 : m_blockIndex(blockIndex) 143 , m_needsNormalLinking(true) 144 , m_needsEarlyReturnLinking(false) 145 { 146 } 147}; 148 149} } // namespace JSC::DFG 150 151#endif // ENABLE(DFG_JIT) 152 153#endif // DFGBasicBlock_h 154 155