dfg/DFGLazyJSValue.h

   1 /*
   2  * Copyright (C) 2013, 2014 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 DFGLazyJSValue_h
  27 #define DFGLazyJSValue_h
  28
  29 #if ENABLE(DFG_JIT)
  30
  31 #include "DFGCommon.h"
  32 #include "DFGFrozenValue.h"
  33 #include <wtf/text/StringImpl.h>
  34
  35 namespace JSC { namespace DFG {
  36
  37 // Represents either a JSValue, or for JSValues that require allocation in the heap,
  38 // it tells you everything you'd need to know in order to allocate it.
  39
  40 enum LazinessKind {
  41     KnownValue,
  42     SingleCharacterString,
  43     KnownStringImpl
  44 };
  45
  46 class LazyJSValue {
  47 public:
  48     LazyJSValue(FrozenValue* value = FrozenValue::emptySingleton())
  49         : m_kind(KnownValue)
  50     {
  51         u.value = value;
  52     }
  53
  54     static LazyJSValue singleCharacterString(UChar character)
  55     {
  56         LazyJSValue result;
  57         result.m_kind = SingleCharacterString;
  58         result.u.character = character;
  59         return result;
  60     }
  61
  62     static LazyJSValue knownStringImpl(StringImpl* string)
  63     {
  64         LazyJSValue result;
  65         result.m_kind = KnownStringImpl;
  66         result.u.stringImpl = string;
  67         return result;
  68     }
  69
  70     FrozenValue* tryGetValue(Graph&) const
  71     {
  72         if (m_kind == KnownValue)
  73             return value();
  74         return nullptr;
  75     }
  76
  77     JSValue getValue(VM&) const;
  78
  79     FrozenValue* value() const
  80     {
  81         ASSERT(m_kind == KnownValue);
  82         return u.value;
  83     }
  84
  85     UChar character() const
  86     {
  87         ASSERT(m_kind == SingleCharacterString);
  88         return u.character;
  89     }
  90
  91     StringImpl* stringImpl() const
  92     {
  93         ASSERT(m_kind == KnownStringImpl);
  94         return u.stringImpl;
  95     }
  96
  97     TriState strictEqual(const LazyJSValue& other) const;
  98
  99     uintptr_t switchLookupValue(SwitchKind) const;
 100
 101     void dump(PrintStream&) const;
 102     void dumpInContext(PrintStream&, DumpContext*) const;
 103
 104 private:
 105     union {
 106         FrozenValue* value;
 107         UChar character;
 108         StringImpl* stringImpl;
 109     } u;
 110     LazinessKind m_kind;
 111 };
 112
 113 } } // namespace JSC::DFG
 114
 115 #endif // ENABLE(DFG_JIT)
 116
 117 #endif // DFGLazyJSValue_h
 118