git.saurik.com Git - apple/javascriptcore.git/blob

1 /*

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 */

26 #include "config.h"

27 #include "DFGMovHintRemovalPhase.h"

29 #if ENABLE(DFG_JIT)

31 #include "BytecodeLivenessAnalysisInlines.h"

32 #include "DFGEpoch.h"

33 #include "DFGForAllKills.h"

34 #include "DFGGraph.h"

35 #include "DFGInsertionSet.h"

36 #include "DFGMayExit.h"

37 #include "DFGPhase.h"

38 #include "JSCInlines.h"

39 #include "OperandsInlines.h"

41 namespace JSC { namespace DFG {

43 namespace {

45 bool verbose = false;

47 class MovHintRemovalPhase : public Phase {

48 public:

49 MovHintRemovalPhase(Graph& graph)

         : Phase(graph, "MovHint removal")

         , m_state(OperandsLike, graph.block(0)->variablesAtHead)

         , m_changed(false)

53 {

54 }

56 bool run()

57 {

58 if (verbose) {

             dataLog("Graph before MovHint removal:\n");

60 m_graph.dump();

61 }

         for (BasicBlock* block : m_graph.blocksInNaturalOrder())

64 handleBlock(block);

66 return m_changed;

67 }

69 private:

     void handleBlock(BasicBlock* block)

71 {

72 if (verbose)

             dataLog("Handing block ", pointerDump(block), "\n");

75 // A MovHint is unnecessary if the local dies before it is used. We answer this question by

76 // maintaining the current exit epoch, and associating an epoch with each local. When a

77 // local dies, it gets the current exit epoch. If a MovHint occurs in the same epoch as its

78 // local, then it means there was no exit between the local's death and the MovHint - i.e.

79 // the MovHint is unnecessary.

         Epoch currentEpoch = Epoch::first();

         m_state.fill(Epoch());

84 m_graph.forAllLiveInBytecode(

             block->terminal()->origin.forExit,

86 [&] (VirtualRegister reg) {

                 m_state.operand(reg) = currentEpoch;

88 });

90 if (verbose)

             dataLog("    Locals: ", m_state, "\n");

93 // Assume that blocks after us exit.

94 currentEpoch.bump();

         for (unsigned nodeIndex = block->size(); nodeIndex--;) {

             Node* node = block->at(nodeIndex);

             if (node->op() == MovHint) {

                 Epoch localEpoch = m_state.operand(node->unlinkedLocal());

101 if (verbose)

                     dataLog("    At ", node, ": current = ", currentEpoch, ", local = ", localEpoch, "\n");

                 if (!localEpoch || localEpoch == currentEpoch) {

104 node->setOpAndDefaultFlags(ZombieHint);

                     node->child1() = Edge();

106 m_changed = true;

107 }

                 m_state.operand(node->unlinkedLocal()) = Epoch();

109 }

110

             if (mayExit(m_graph, node))

112 currentEpoch.bump();

113

114 if (nodeIndex) {

115 forAllKilledOperands(

                     m_graph, block->at(nodeIndex - 1), node,

117 [&] (VirtualRegister reg) {

118 // This function is a bit sloppy - it might claim to kill a local even if

119 // it's still live after. We need to protect against that.

                         if (!!m_state.operand(reg))

121 return;

122

123 if (verbose)

                             dataLog("    Killed operand at ", node, ": ", reg, "\n");

                         m_state.operand(reg) = currentEpoch;

126 });

127 }

128 }

129 }

130

131 Operands<Epoch> m_state;

132 bool m_changed;

133 };

134

135 } // anonymous namespace

136

 bool performMovHintRemoval(Graph& graph)

138 {

139 SamplingRegion samplingRegion("DFG MovHint Removal Phase");

140 return runPhase<MovHintRemovalPhase>(graph);

141 }

142

143 } } // namespace JSC::DFG

144

145 #endif // ENABLE(DFG_JIT)

146