dfg/DFGArgumentPosition.h

   1 /*
   2  * Copyright (C) 2012, 2013, 2015 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 DFGArgumentPosition_h
  27 #define DFGArgumentPosition_h
  28
  29 #include "DFGDoubleFormatState.h"
  30 #include "DFGVariableAccessData.h"
  31 #include "DFGVariableAccessDataDump.h"
  32 #include "SpeculatedType.h"
  33
  34 namespace JSC { namespace DFG {
  35
  36 class ArgumentPosition {
  37 public:
  38     ArgumentPosition()
  39         : m_prediction(SpecNone)
  40         , m_doubleFormatState(EmptyDoubleFormatState)
  41         , m_isProfitableToUnbox(false)
  42         , m_shouldNeverUnbox(false)
  43     {
  44     }
  45
  46     void addVariable(VariableAccessData* variable)
  47     {
  48         m_variables.append(variable);
  49
  50         // We may set this early. Merging it here saves us time in prediction propagation.
  51         variable->mergeShouldNeverUnbox(m_shouldNeverUnbox);
  52     }
  53
  54     VariableAccessData* someVariable() const
  55     {
  56         if (m_variables.isEmpty())
  57             return 0;
  58         return m_variables[0]->find();
  59     }
  60
  61     FlushFormat flushFormat() const
  62     {
  63         if (VariableAccessData* variable = someVariable())
  64             return variable->flushFormat();
  65         return DeadFlush;
  66     }
  67
  68     bool mergeShouldNeverUnbox(bool shouldNeverUnbox)
  69     {
  70         return checkAndSet(m_shouldNeverUnbox, m_shouldNeverUnbox || shouldNeverUnbox);
  71     }
  72
  73     bool mergeArgumentPredictionAwareness()
  74     {
  75         bool changed = false;
  76         for (unsigned i = 0; i < m_variables.size(); ++i) {
  77             VariableAccessData* variable = m_variables[i]->find();
  78             changed |= mergeSpeculation(m_prediction, variable->argumentAwarePrediction());
  79             changed |= mergeDoubleFormatState(m_doubleFormatState, variable->doubleFormatState());
  80             changed |= mergeShouldNeverUnbox(variable->shouldNeverUnbox());
  81         }
  82         if (!changed)
  83             return false;
  84         changed = false;
  85         for (unsigned i = 0; i < m_variables.size(); ++i) {
  86             VariableAccessData* variable = m_variables[i]->find();
  87             changed |= variable->mergeArgumentAwarePrediction(m_prediction);
  88             changed |= variable->mergeDoubleFormatState(m_doubleFormatState);
  89             changed |= variable->mergeShouldNeverUnbox(m_shouldNeverUnbox);
  90         }
  91         return changed;
  92     }
  93
  94     bool mergeArgumentUnboxingAwareness()
  95     {
  96         bool changed = false;
  97         for (unsigned i = 0; i < m_variables.size(); ++i) {
  98             VariableAccessData* variable = m_variables[i]->find();
  99             changed |= checkAndSet(m_isProfitableToUnbox, m_isProfitableToUnbox || variable->isProfitableToUnbox());
 100         }
 101         if (!changed)
 102             return false;
 103         changed = false;
 104         for (unsigned i = 0; i < m_variables.size(); ++i) {
 105             VariableAccessData* variable = m_variables[i]->find();
 106             changed |= variable->mergeIsProfitableToUnbox(m_isProfitableToUnbox);
 107         }
 108         return changed;
 109     }
 110
 111     bool shouldUnboxIfPossible() const { return m_isProfitableToUnbox && !m_shouldNeverUnbox; }
 112
 113     SpeculatedType prediction() const { return m_prediction; }
 114     DoubleFormatState doubleFormatState() const { return m_doubleFormatState; }
 115     bool shouldUseDoubleFormat() const
 116     {
 117         return doubleFormatState() == UsingDoubleFormat && shouldUnboxIfPossible();
 118     }
 119
 120     void dump(PrintStream& out, Graph* graph)
 121     {
 122         for (unsigned i = 0; i < m_variables.size(); ++i) {
 123             VariableAccessData* variable = m_variables[i]->find();
 124             VirtualRegister operand = variable->local();
 125
 126             if (i)
 127                 out.print(" ");
 128
 129             out.print(operand, "(", VariableAccessDataDump(*graph, variable), ")");
 130         }
 131         out.print("\n");
 132     }
 133
 134 private:
 135     SpeculatedType m_prediction;
 136     DoubleFormatState m_doubleFormatState;
 137     bool m_isProfitableToUnbox;
 138     bool m_shouldNeverUnbox;
 139
 140     Vector<VariableAccessData*, 2> m_variables;
 141 };
 142
 143 } } // namespace JSC::DFG
 144
 145 #endif // DFGArgumentPosition_h
 146