Source/JavaScriptCore/dfg/DFGLazyJSValue.cpp

   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 #include "config.h"
  27
  28 #if ENABLE(DFG_JIT)
  29
  30 #include "DFGLazyJSValue.h"
  31
  32 #include "Operations.h"
  33
  34 namespace JSC { namespace DFG {
  35
  36 JSValue LazyJSValue::getValue(VM& vm) const
  37 {
  38     switch (m_kind) {
  39     case KnownValue:
  40         return value();
  41     case SingleCharacterString:
  42         return jsSingleCharacterString(&vm, u.character);
  43     case KnownStringImpl:
  44         return jsString(&vm, u.stringImpl);
  45     }
  46     RELEASE_ASSERT_NOT_REACHED();
  47     return value();
  48 }
  49
  50 static TriState equalToSingleCharacter(JSValue value, UChar character)
  51 {
  52     if (!value.isString())
  53         return FalseTriState;
  54
  55     JSString* jsString = asString(value);
  56     if (jsString->length() != 1)
  57         return FalseTriState;
  58
  59     const StringImpl* string = jsString->tryGetValueImpl();
  60     if (!string)
  61         return MixedTriState;
  62
  63     return triState(string->at(0) == character);
  64 }
  65
  66 static TriState equalToStringImpl(JSValue value, StringImpl* stringImpl)
  67 {
  68     if (!value.isString())
  69         return FalseTriState;
  70
  71     JSString* jsString = asString(value);
  72     const StringImpl* string = jsString->tryGetValueImpl();
  73     if (!string)
  74         return MixedTriState;
  75
  76     return triState(WTF::equal(stringImpl, string));
  77 }
  78
  79 TriState LazyJSValue::strictEqual(const LazyJSValue& other) const
  80 {
  81     switch (m_kind) {
  82     case KnownValue:
  83         switch (other.m_kind) {
  84         case KnownValue:
  85             return JSValue::pureStrictEqual(value(), other.value());
  86         case SingleCharacterString:
  87             return equalToSingleCharacter(value(), other.character());
  88         case KnownStringImpl:
  89             return equalToStringImpl(value(), other.stringImpl());
  90         }
  91         break;
  92     case SingleCharacterString:
  93         switch (other.m_kind) {
  94         case SingleCharacterString:
  95             return triState(character() == other.character());
  96         case KnownStringImpl:
  97             if (other.stringImpl()->length() != 1)
  98                 return FalseTriState;
  99             return triState(other.stringImpl()->at(0) == character());
 100         default:
 101             return other.strictEqual(*this);
 102         }
 103         break;
 104     case KnownStringImpl:
 105         switch (other.m_kind) {
 106         case KnownStringImpl:
 107             return triState(WTF::equal(stringImpl(), other.stringImpl()));
 108         default:
 109             return other.strictEqual(*this);
 110         }
 111         break;
 112     }
 113     RELEASE_ASSERT_NOT_REACHED();
 114     return FalseTriState;
 115 }
 116
 117 void LazyJSValue::dumpInContext(PrintStream& out, DumpContext* context) const
 118 {
 119     switch (m_kind) {
 120     case KnownValue:
 121         value().dumpInContext(out, context);
 122         return;
 123     case SingleCharacterString:
 124         out.print("Lazy:SingleCharacterString(");
 125         out.printf("%04X", static_cast<unsigned>(character()));
 126         out.print(" / ", StringImpl::utf8ForCharacters(&u.character, 1), ")");
 127         return;
 128     case KnownStringImpl:
 129         out.print("Lazy:String(", stringImpl(), ")");
 130         return;
 131     }
 132     RELEASE_ASSERT_NOT_REACHED();
 133 }
 134
 135 void LazyJSValue::dump(PrintStream& out) const
 136 {
 137     dumpInContext(out, 0);
 138 }
 139
 140 } } // namespace JSC::DFG
 141
 142 #endif // ENABLE(DFG_JIT)
 143