dfg/DFGFrozenValue.h

   1 /*
   2  * Copyright (C) 2014, 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 DFGFrozenValue_h
  27 #define DFGFrozenValue_h
  28
  29 #if ENABLE(DFG_JIT)
  30
  31 #include "DFGValueStrength.h"
  32 #include "JSCell.h"
  33 #include "JSCJSValue.h"
  34 #include "Structure.h"
  35
  36 namespace JSC { namespace DFG {
  37
  38 class Graph;
  39
  40 class FrozenValue {
  41 public:
  42     FrozenValue()
  43         : m_structure(nullptr)
  44         , m_strength(WeakValue)
  45     {
  46     }
  47
  48     FrozenValue(JSValue value)
  49         : m_value(value)
  50         , m_structure(nullptr)
  51         , m_strength(WeakValue)
  52     {
  53         RELEASE_ASSERT(!value || !value.isCell());
  54     }
  55
  56     FrozenValue(JSValue value, Structure* structure, ValueStrength strength)
  57         : m_value(value)
  58         , m_structure(structure)
  59         , m_strength(strength)
  60     {
  61         ASSERT((!!value && value.isCell()) == !!structure);
  62         ASSERT(!value || !value.isCell() || value.asCell()->classInfo() == structure->classInfo());
  63         ASSERT(!!structure || (strength == WeakValue));
  64     }
  65
  66     static FrozenValue* emptySingleton();
  67
  68     bool operator!() const { return !m_value; }
  69
  70     JSValue value() const { return m_value; }
  71     JSCell* cell() const { return m_value.asCell(); }
  72
  73     template<typename T>
  74     T dynamicCast()
  75     {
  76         return jsDynamicCast<T>(value());
  77     }
  78     template<typename T>
  79     T cast()
  80     {
  81         return jsCast<T>(value());
  82     }
  83
  84     Structure* structure() const { return m_structure; }
  85
  86     void strengthenTo(ValueStrength strength)
  87     {
  88         if (!!m_value && m_value.isCell())
  89             m_strength = merge(m_strength, strength);
  90     }
  91
  92     bool pointsToHeap() const { return !!value() && value().isCell(); }
  93
  94     // The strength of the value itself. The structure is almost always weak.
  95     ValueStrength strength() const { return m_strength; }
  96
  97     void dumpInContext(PrintStream& out, DumpContext* context) const;
  98     void dump(PrintStream& out) const;
  99
 100 private:
 101     friend class Graph;
 102
 103     // This is a utility method for DFG::Graph::freeze(). You should almost always call
 104     // Graph::freeze() directly. Calling this instead of Graph::freeze() can result in
 105     // the same constant being viewed as having different structures during the course
 106     // of compilation, which can sometimes cause bad things to happen. For example, we
 107     // may observe that one version of the constant has an unwatchable structure but
 108     // then a later version may start to have a watchable structure due to a transition.
 109     // The point of freezing is to ensure that we generally only see one version of
 110     // constants, but that requires freezing through the Graph.
 111     static FrozenValue freeze(JSValue value)
 112     {
 113         return FrozenValue(
 114             value,
 115             (!!value && value.isCell()) ? value.asCell()->structure() : nullptr,
 116             WeakValue);
 117     }
 118
 119     JSValue m_value;
 120     Structure* m_structure;
 121     ValueStrength m_strength;
 122 };
 123
 124 } } // namespace JSC::DFG
 125
 126 #endif // ENABLE(DFG_JIT)
 127
 128 #endif // DFGFrozenValue_h
 129