dfg/DFGAvailability.h

   1 /*
   2  * Copyright (C) 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 DFGAvailability_h
  27 #define DFGAvailability_h
  28
  29 #if ENABLE(DFG_JIT)
  30
  31 #include "DFGFlushedAt.h"
  32 #include "DFGVariableAccessData.h"
  33
  34 namespace JSC { namespace DFG {
  35
  36 struct Node;
  37
  38 class Availability {
  39 public:
  40     Availability()
  41         : m_node(0)
  42         , m_flushedAt(DeadFlush)
  43     {
  44     }
  45
  46     explicit Availability(Node* node)
  47         : m_node(node)
  48         , m_flushedAt(ConflictingFlush)
  49     {
  50     }
  51
  52     explicit Availability(FlushedAt flushedAt)
  53         : m_node(unavailableMarker())
  54         , m_flushedAt(flushedAt)
  55     {
  56     }
  57
  58     Availability(Node* node, FlushedAt flushedAt)
  59         : m_node(node)
  60         , m_flushedAt(flushedAt)
  61     {
  62     }
  63
  64     static Availability unavailable()
  65     {
  66         return Availability(unavailableMarker(), FlushedAt(ConflictingFlush));
  67     }
  68
  69     Availability withFlush(FlushedAt flush) const
  70     {
  71         return Availability(m_node, flush);
  72     }
  73
  74     Availability withNode(Node* node) const
  75     {
  76         return Availability(node, m_flushedAt);
  77     }
  78
  79     Availability withUnavailableNode() const
  80     {
  81         return withNode(unavailableMarker());
  82     }
  83
  84     bool nodeIsUndecided() const { return !m_node; }
  85     bool nodeIsUnavailable() const { return m_node == unavailableMarker(); }
  86
  87     bool hasNode() const { return !nodeIsUndecided() && !nodeIsUnavailable(); }
  88
  89     Node* node() const
  90     {
  91         ASSERT(!nodeIsUndecided());
  92         ASSERT(!nodeIsUnavailable());
  93         return m_node;
  94     }
  95
  96     FlushedAt flushedAt() const { return m_flushedAt; }
  97
  98     bool operator!() const { return nodeIsUnavailable() && flushedAt().format() == ConflictingFlush; }
  99
 100     bool operator==(const Availability& other) const
 101     {
 102         return m_node == other.m_node
 103             && m_flushedAt == other.m_flushedAt;
 104     }
 105
 106     Availability merge(const Availability& other) const
 107     {
 108         return Availability(
 109             mergeNodes(m_node, other.m_node),
 110             m_flushedAt.merge(other.m_flushedAt));
 111     }
 112
 113     void dump(PrintStream&) const;
 114     void dumpInContext(PrintStream&, DumpContext*) const;
 115
 116 private:
 117     static Node* mergeNodes(Node* a, Node* b)
 118     {
 119         if (!a)
 120             return b;
 121         if (!b)
 122             return a;
 123         if (a == b)
 124             return a;
 125         return unavailableMarker();
 126     }
 127
 128     static Node* unavailableMarker()
 129     {
 130         return bitwise_cast<Node*>(static_cast<intptr_t>(1));
 131     }
 132
 133     Node* m_node;
 134     FlushedAt m_flushedAt;
 135 };
 136
 137 } } // namespace JSC::DFG
 138
 139 #endif // ENABLE(DFG_JIT)
 140
 141 #endif // DFGAvailability_h
 142