1 /* 2 * Copyright (C) 2011 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 DFGAliasTracker_h 27 #define DFGAliasTracker_h 28 29 #if ENABLE(DFG_JIT) 30 31 #include <dfg/DFGGraph.h> 32 #include <wtf/Vector.h> 33 34 namespace JSC { namespace DFG { 35 36 // === AliasTracker === 37 // 38 // This class id used to detect aliasing property accesses, which we may 39 // be able to speculatively optimize (for example removing redundant loads 40 // where we know a getter will not be called, or optimizing puts to arrays 41 // where we know the value being written to in within length and is not a 42 // hole value). In time, this should be more than a 1-deep buffer! 43 class AliasTracker { 44 public: AliasTracker(Graph & graph)45 AliasTracker(Graph& graph) 46 : m_graph(graph) 47 , m_candidateAliasGetByVal(NoNode) 48 { 49 } 50 lookupGetByVal(NodeIndex base,NodeIndex property)51 NodeIndex lookupGetByVal(NodeIndex base, NodeIndex property) 52 { 53 // Try to detect situations where a GetByVal follows another GetByVal to the same 54 // property; in these cases, we may be able to omit the subsequent get on the 55 // speculative path, where we know conditions hold to make this safe (for example, 56 // on the speculative path we will not have allowed getter access). 57 if (m_candidateAliasGetByVal != NoNode) { 58 Node& possibleAlias = m_graph[m_candidateAliasGetByVal]; 59 ASSERT(possibleAlias.op == GetByVal); 60 // This check ensures the accesses alias, provided that the subscript is an 61 // integer index (this is good enough; the speculative path will only generate 62 // optimized accesses to handle integer subscripts). 63 if (possibleAlias.child1 == base && equalIgnoringLaterNumericConversion(possibleAlias.child2, property)) 64 return m_candidateAliasGetByVal; 65 } 66 return NoNode; 67 } 68 recordGetByVal(NodeIndex getByVal)69 void recordGetByVal(NodeIndex getByVal) 70 { 71 m_candidateAliasGetByVal = getByVal; 72 } 73 recordPutByVal(NodeIndex putByVal)74 void recordPutByVal(NodeIndex putByVal) 75 { 76 ASSERT_UNUSED(putByVal, m_graph[putByVal].op == PutByVal || m_graph[putByVal].op == PutByValAlias); 77 m_candidateAliasGetByVal = NoNode; 78 } 79 recordGetById(NodeIndex getById)80 void recordGetById(NodeIndex getById) 81 { 82 ASSERT_UNUSED(getById, m_graph[getById].op == GetById); 83 m_candidateAliasGetByVal = NoNode; 84 } 85 recordPutById(NodeIndex putById)86 void recordPutById(NodeIndex putById) 87 { 88 ASSERT_UNUSED(putById, m_graph[putById].op == PutById); 89 m_candidateAliasGetByVal = NoNode; 90 } 91 recordPutByIdDirect(NodeIndex putByVal)92 void recordPutByIdDirect(NodeIndex putByVal) 93 { 94 ASSERT_UNUSED(putByVal, m_graph[putByVal].op == PutByIdDirect); 95 m_candidateAliasGetByVal = NoNode; 96 } 97 98 private: 99 // This method returns true for arguments: 100 // - (X, X) 101 // - (X, ValueToNumber(X)) 102 // - (X, ValueToInt32(X)) 103 // - (X, NumberToInt32(X)) equalIgnoringLaterNumericConversion(NodeIndex op1,NodeIndex op2)104 bool equalIgnoringLaterNumericConversion(NodeIndex op1, NodeIndex op2) 105 { 106 if (op1 == op2) 107 return true; 108 Node& node2 = m_graph[op2]; 109 return (node2.op == ValueToNumber || node2.op == ValueToInt32 || node2.op == NumberToInt32) && op1 == node2.child1; 110 } 111 112 // The graph, to look up potentially aliasing nodes. 113 Graph& m_graph; 114 // Currently a 1-deep buffer! 115 NodeIndex m_candidateAliasGetByVal; 116 }; 117 118 } } // namespace JSC::DFG 119 120 #endif 121 #endif 122