X-Git-Url: https://git.saurik.com/apple/javascriptcore.git/blobdiff_plain/6fe7ccc865dc7d7541b93c5bcaf6368d2c98a174..81345200c95645a1b0d2635520f96ad55dfde63f:/runtime/JSString.cpp?ds=sidebyside diff --git a/runtime/JSString.cpp b/runtime/JSString.cpp index 904cc4d..10a16d9 100644 --- a/runtime/JSString.cpp +++ b/runtime/JSString.cpp @@ -26,31 +26,47 @@ #include "JSGlobalObject.h" #include "JSGlobalObjectFunctions.h" #include "JSObject.h" -#include "Operations.h" +#include "JSCInlines.h" #include "StringObject.h" #include "StringPrototype.h" +#include "StrongInlines.h" namespace JSC { -static const unsigned substringFromRopeCutoff = 4; - const ClassInfo JSString::s_info = { "string", 0, 0, 0, CREATE_METHOD_TABLE(JSString) }; void JSRopeString::RopeBuilder::expand() { ASSERT(m_index == JSRopeString::s_maxInternalRopeLength); JSString* jsString = m_jsString; - m_jsString = jsStringBuilder(&m_globalData); + RELEASE_ASSERT(jsString); + m_jsString = jsStringBuilder(&m_vm); m_index = 0; append(jsString); } void JSString::destroy(JSCell* cell) { - JSString* thisObject = jsCast(cell); + JSString* thisObject = static_cast(cell); thisObject->JSString::~JSString(); } +void JSString::dumpToStream(const JSCell* cell, PrintStream& out) +{ + const JSString* thisObject = jsCast(cell); + out.printf("<%p, %s, [%u], ", thisObject, thisObject->className(), thisObject->length()); + if (thisObject->isRope()) + out.printf("[rope]"); + else { + WTF::StringImpl* ourImpl = thisObject->m_value.impl(); + if (ourImpl->is8Bit()) + out.printf("[8 %p]", ourImpl->characters8()); + else + out.printf("[16 %p]", ourImpl->characters16()); + } + out.printf(">"); +} + void JSString::visitChildren(JSCell* cell, SlotVisitor& visitor) { JSString* thisObject = jsCast(cell); @@ -58,6 +74,11 @@ void JSString::visitChildren(JSCell* cell, SlotVisitor& visitor) if (thisObject->isRope()) static_cast(thisObject)->visitFibers(visitor); + else { + StringImpl* impl = thisObject->m_value.impl(); + ASSERT(impl); + visitor.reportExtraMemoryUsage(thisObject, impl->costDuringGC()); + } } void JSRopeString::visitFibers(SlotVisitor& visitor) @@ -66,6 +87,113 @@ void JSRopeString::visitFibers(SlotVisitor& visitor) visitor.append(&m_fibers[i]); } +static const unsigned maxLengthForOnStackResolve = 2048; + +void JSRopeString::resolveRopeInternal8(LChar* buffer) const +{ + for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) { + if (m_fibers[i]->isRope()) { + resolveRopeSlowCase8(buffer); + return; + } + } + + LChar* position = buffer; + for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) { + const StringImpl& fiberString = *m_fibers[i]->m_value.impl(); + unsigned length = fiberString.length(); + StringImpl::copyChars(position, fiberString.characters8(), length); + position += length; + } + ASSERT((buffer + m_length) == position); +} + +void JSRopeString::resolveRopeInternal16(UChar* buffer) const +{ + for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) { + if (m_fibers[i]->isRope()) { + resolveRopeSlowCase(buffer); + return; + } + } + + UChar* position = buffer; + for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) { + const StringImpl& fiberString = *m_fibers[i]->m_value.impl(); + unsigned length = fiberString.length(); + if (fiberString.is8Bit()) + StringImpl::copyChars(position, fiberString.characters8(), length); + else + StringImpl::copyChars(position, fiberString.characters16(), length); + position += length; + } + ASSERT((buffer + m_length) == position); +} + +void JSRopeString::resolveRopeToAtomicString(ExecState* exec) const +{ + if (m_length > maxLengthForOnStackResolve) { + resolveRope(exec); + m_value = AtomicString(m_value); + return; + } + + if (is8Bit()) { + LChar buffer[maxLengthForOnStackResolve]; + resolveRopeInternal8(buffer); + m_value = AtomicString(buffer, m_length); + } else { + UChar buffer[maxLengthForOnStackResolve]; + resolveRopeInternal16(buffer); + m_value = AtomicString(buffer, m_length); + } + + clearFibers(); + + // If we resolved a string that didn't previously exist, notify the heap that we've grown. + if (m_value.impl()->hasOneRef()) + Heap::heap(this)->reportExtraMemoryCost(m_value.impl()->cost()); +} + +void JSRopeString::clearFibers() const +{ + for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) + m_fibers[i].clear(); +} + +AtomicStringImpl* JSRopeString::resolveRopeToExistingAtomicString(ExecState* exec) const +{ + if (m_length > maxLengthForOnStackResolve) { + resolveRope(exec); + if (AtomicStringImpl* existingAtomicString = AtomicString::find(m_value.impl())) { + m_value = *existingAtomicString; + clearFibers(); + return existingAtomicString; + } + return nullptr; + } + + if (is8Bit()) { + LChar buffer[maxLengthForOnStackResolve]; + resolveRopeInternal8(buffer); + if (AtomicStringImpl* existingAtomicString = AtomicString::find(buffer, m_length)) { + m_value = *existingAtomicString; + clearFibers(); + return existingAtomicString; + } + } else { + UChar buffer[maxLengthForOnStackResolve]; + resolveRopeInternal16(buffer); + if (AtomicStringImpl* existingAtomicString = AtomicString::find(buffer, m_length)) { + m_value = *existingAtomicString; + clearFibers(); + return existingAtomicString; + } + } + + return nullptr; +} + void JSRopeString::resolveRope(ExecState* exec) const { ASSERT(isRope()); @@ -79,23 +207,9 @@ void JSRopeString::resolveRope(ExecState* exec) const outOfMemory(exec); return; } - - for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) { - if (m_fibers[i]->isRope()) - return resolveRopeSlowCase8(buffer); - } - - LChar* position = buffer; - for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) { - StringImpl* string = m_fibers[i]->m_value.impl(); - unsigned length = string->length(); - StringImpl::copyChars(position, string->characters8(), length); - position += length; - m_fibers[i].clear(); - } - ASSERT((buffer + m_length) == position); + resolveRopeInternal8(buffer); + clearFibers(); ASSERT(!isRope()); - return; } @@ -108,25 +222,13 @@ void JSRopeString::resolveRope(ExecState* exec) const return; } - for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) { - if (m_fibers[i]->isRope()) - return resolveRopeSlowCase(buffer); - } - - UChar* position = buffer; - for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) { - StringImpl* string = m_fibers[i]->m_value.impl(); - unsigned length = string->length(); - StringImpl::copyChars(position, string->characters(), length); - position += length; - m_fibers[i].clear(); - } - ASSERT((buffer + m_length) == position); + resolveRopeInternal16(buffer); + clearFibers(); ASSERT(!isRope()); } // Overview: These functions convert a JSString from holding a string in rope form -// down to a simple UString representation. It does so by building up the string +// down to a simple String representation. It does so by building up the string // backwards, since we want to avoid recursion, we expect that the tree structure // representing the rope is likely imbalanced with more nodes down the left side // (since appending to the string is likely more common) - and as such resolving @@ -138,13 +240,10 @@ void JSRopeString::resolveRope(ExecState* exec) const void JSRopeString::resolveRopeSlowCase8(LChar* buffer) const { LChar* position = buffer + m_length; // We will be working backwards over the rope. - Vector workQueue; // Putting strings into a Vector is only OK because there are no GC points in this method. + Vector workQueue; // Putting strings into a Vector is only OK because there are no GC points in this method. - for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) { + for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) workQueue.append(m_fibers[i].get()); - // Clearing here works only because there are no GC points in this method. - m_fibers[i].clear(); - } while (!workQueue.isEmpty()) { JSString* currentFiber = workQueue.last(); @@ -164,13 +263,12 @@ void JSRopeString::resolveRopeSlowCase8(LChar* buffer) const } ASSERT(buffer == position); - ASSERT(!isRope()); } void JSRopeString::resolveRopeSlowCase(UChar* buffer) const { UChar* position = buffer + m_length; // We will be working backwards over the rope. - Vector workQueue; // These strings are kept alive by the parent rope, so using a Vector is OK. + Vector workQueue; // These strings are kept alive by the parent rope, so using a Vector is OK. for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) workQueue.append(m_fibers[i].get()); @@ -189,19 +287,20 @@ void JSRopeString::resolveRopeSlowCase(UChar* buffer) const StringImpl* string = static_cast(currentFiber->m_value.impl()); unsigned length = string->length(); position -= length; - StringImpl::copyChars(position, string->characters(), length); + if (string->is8Bit()) + StringImpl::copyChars(position, string->characters8(), length); + else + StringImpl::copyChars(position, string->characters16(), length); } ASSERT(buffer == position); - ASSERT(!isRope()); } void JSRopeString::outOfMemory(ExecState* exec) const { - for (size_t i = 0; i < s_maxInternalRopeLength && m_fibers[i]; ++i) - m_fibers[i].clear(); + clearFibers(); ASSERT(isRope()); - ASSERT(m_value == UString()); + ASSERT(m_value.isNull()); if (exec) throwOutOfMemoryError(exec); } @@ -212,9 +311,9 @@ JSString* JSRopeString::getIndexSlowCase(ExecState* exec, unsigned i) resolveRope(exec); // Return a safe no-value result, this should never be used, since the excetion will be thrown. if (exec->exception()) - return jsString(exec, ""); + return jsEmptyString(exec); ASSERT(!isRope()); - ASSERT(i < m_value.length()); + RELEASE_ASSERT(i < m_value.length()); return jsSingleCharacterSubstring(exec, m_value, i); } @@ -230,7 +329,7 @@ bool JSString::getPrimitiveNumber(ExecState* exec, double& number, JSValue& resu return false; } -bool JSString::toBoolean(ExecState*) const +bool JSString::toBoolean() const { return m_length; } @@ -240,51 +339,35 @@ double JSString::toNumber(ExecState* exec) const return jsToNumber(value(exec)); } -inline StringObject* StringObject::create(ExecState* exec, JSGlobalObject* globalObject, JSString* string) +inline StringObject* StringObject::create(VM& vm, JSGlobalObject* globalObject, JSString* string) { - StringObject* object = new (NotNull, allocateCell(*exec->heap())) StringObject(exec->globalData(), globalObject->stringObjectStructure()); - object->finishCreation(exec->globalData(), string); + StringObject* object = new (NotNull, allocateCell(vm.heap)) StringObject(vm, globalObject->stringObjectStructure()); + object->finishCreation(vm, string); return object; } JSObject* JSString::toObject(ExecState* exec, JSGlobalObject* globalObject) const { - return StringObject::create(exec, globalObject, const_cast(this)); + return StringObject::create(exec->vm(), globalObject, const_cast(this)); } -JSObject* JSString::toThisObject(JSCell* cell, ExecState* exec) +JSValue JSString::toThis(JSCell* cell, ExecState* exec, ECMAMode ecmaMode) { - return StringObject::create(exec, exec->lexicalGlobalObject(), jsCast(cell)); + if (ecmaMode == StrictMode) + return cell; + return StringObject::create(exec->vm(), exec->lexicalGlobalObject(), jsCast(cell)); } -bool JSString::getOwnPropertySlot(JSCell* cell, ExecState* exec, const Identifier& propertyName, PropertySlot& slot) -{ - JSString* thisObject = jsCast(cell); - // The semantics here are really getPropertySlot, not getOwnPropertySlot. - // This function should only be called by JSValue::get. - if (thisObject->getStringPropertySlot(exec, propertyName, slot)) - return true; - slot.setBase(thisObject); - JSObject* object; - for (JSValue prototype = exec->lexicalGlobalObject()->stringPrototype(); !prototype.isNull(); prototype = object->prototype()) { - object = asObject(prototype); - if (object->methodTable()->getOwnPropertySlot(object, exec, propertyName, slot)) - return true; - } - slot.setUndefined(); - return true; -} - -bool JSString::getStringPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor) +bool JSString::getStringPropertyDescriptor(ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor) { if (propertyName == exec->propertyNames().length) { descriptor.setDescriptor(jsNumber(m_length), DontEnum | DontDelete | ReadOnly); return true; } - bool isStrictUInt32; - unsigned i = propertyName.toUInt32(isStrictUInt32); - if (isStrictUInt32 && i < m_length) { + unsigned i = propertyName.asIndex(); + if (i < m_length) { + ASSERT(i != PropertyName::NotAnIndex); // No need for an explicit check, the above test would always fail! descriptor.setDescriptor(getIndex(exec, i), DontDelete | ReadOnly); return true; } @@ -292,14 +375,13 @@ bool JSString::getStringPropertyDescriptor(ExecState* exec, const Identifier& pr return false; } -bool JSString::getOwnPropertySlotByIndex(JSCell* cell, ExecState* exec, unsigned propertyName, PropertySlot& slot) +JSString* jsStringWithCacheSlowCase(VM& vm, StringImpl& stringImpl) { - JSString* thisObject = jsCast(cell); - // The semantics here are really getPropertySlot, not getOwnPropertySlot. - // This function should only be called by JSValue::get. - if (thisObject->getStringPropertySlot(exec, propertyName, slot)) - return true; - return JSString::getOwnPropertySlot(thisObject, exec, Identifier::from(exec, propertyName), slot); + auto addResult = vm.stringCache.add(&stringImpl, nullptr); + if (addResult.isNewEntry) + addResult.iterator->value = jsString(&vm, String(stringImpl)); + vm.lastCachedString.set(vm, addResult.iterator->value.get()); + return addResult.iterator->value.get(); } } // namespace JSC