blob: 8c7a3032217b4595d800b23ebe7ff2ff6633ceda [file] [log] [blame]
/*
* Copyright (C) 1999-2002 Harri Porten (porten@kde.org)
* Copyright (C) 2001 Peter Kelly (pmk@post.com)
* Copyright (C) 2004-2021 Apple Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#include "config.h"
#include "JSString.h"
#include "JSGlobalObjectFunctions.h"
#include "JSGlobalObjectInlines.h"
#include "JSObjectInlines.h"
#include "StringObject.h"
#include "StrongInlines.h"
#include "StructureInlines.h"
namespace JSC {
const ClassInfo JSString::s_info = { "string"_s, nullptr, nullptr, nullptr, CREATE_METHOD_TABLE(JSString) };
Structure* JSString::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue proto)
{
return Structure::create(vm, globalObject, proto, TypeInfo(StringType, StructureFlags), info());
}
JSString* JSString::createEmptyString(VM& vm)
{
JSString* newString = new (NotNull, allocateCell<JSString>(vm)) JSString(vm, *StringImpl::empty());
newString->finishCreation(vm);
return newString;
}
template<>
void JSRopeString::RopeBuilder<RecordOverflow>::expand()
{
RELEASE_ASSERT(!this->hasOverflowed());
ASSERT(m_strings.size() == JSRopeString::s_maxInternalRopeLength);
static_assert(3 == JSRopeString::s_maxInternalRopeLength);
ASSERT(m_length);
ASSERT(asString(m_strings.at(0))->length());
ASSERT(asString(m_strings.at(1))->length());
ASSERT(asString(m_strings.at(2))->length());
JSString* string = JSRopeString::create(m_vm, asString(m_strings.at(0)), asString(m_strings.at(1)), asString(m_strings.at(2)));
ASSERT(string->length() == m_length);
m_strings.clear();
m_strings.append(string);
}
void JSString::dumpToStream(const JSCell* cell, PrintStream& out)
{
const JSString* thisObject = jsCast<const JSString*>(cell);
out.printf("<%p, %s, [%u], ", thisObject, thisObject->className().characters(), thisObject->length());
uintptr_t pointer = thisObject->fiberConcurrently();
if (pointer & isRopeInPointer) {
if (pointer & JSRopeString::isSubstringInPointer)
out.printf("[substring]");
else
out.printf("[rope]");
} else {
if (WTF::StringImpl* ourImpl = bitwise_cast<StringImpl*>(pointer)) {
if (ourImpl->is8Bit())
out.printf("[8 %p]", ourImpl->characters8());
else
out.printf("[16 %p]", ourImpl->characters16());
}
}
out.printf(">");
}
bool JSString::equalSlowCase(JSGlobalObject* globalObject, JSString* other) const
{
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (length() != other->length())
return false;
String str1 = value(globalObject);
RETURN_IF_EXCEPTION(scope, false);
String str2 = other->value(globalObject);
RETURN_IF_EXCEPTION(scope, false);
return WTF::equal(*str1.impl(), *str2.impl());
}
size_t JSString::estimatedSize(JSCell* cell, VM& vm)
{
JSString* thisObject = asString(cell);
uintptr_t pointer = thisObject->fiberConcurrently();
if (pointer & isRopeInPointer)
return Base::estimatedSize(cell, vm);
return Base::estimatedSize(cell, vm) + bitwise_cast<StringImpl*>(pointer)->costDuringGC();
}
template<typename Visitor>
void JSString::visitChildrenImpl(JSCell* cell, Visitor& visitor)
{
JSString* thisObject = asString(cell);
ASSERT_GC_OBJECT_INHERITS(thisObject, info());
Base::visitChildren(thisObject, visitor);
uintptr_t pointer = thisObject->fiberConcurrently();
if (pointer & isRopeInPointer) {
if (pointer & JSRopeString::isSubstringInPointer) {
visitor.appendUnbarriered(static_cast<JSRopeString*>(thisObject)->fiber1());
return;
}
for (unsigned index = 0; index < JSRopeString::s_maxInternalRopeLength; ++index) {
JSString* fiber = nullptr;
switch (index) {
case 0:
fiber = bitwise_cast<JSString*>(pointer & JSRopeString::stringMask);
break;
case 1:
fiber = static_cast<JSRopeString*>(thisObject)->fiber1();
break;
case 2:
fiber = static_cast<JSRopeString*>(thisObject)->fiber2();
break;
default:
ASSERT_NOT_REACHED();
return;
}
if (!fiber)
break;
visitor.appendUnbarriered(fiber);
}
return;
}
if (StringImpl* impl = bitwise_cast<StringImpl*>(pointer))
visitor.reportExtraMemoryVisited(impl->costDuringGC());
}
DEFINE_VISIT_CHILDREN(JSString);
static constexpr unsigned maxLengthForOnStackResolve = 2048;
template<typename CharacterType>
void JSRopeString::resolveRopeInternal(CharacterType* buffer) const
{
if (isSubstring()) {
// It is possible that underlying string becomes 8bit/16bit while wrapper substring is saying it is 16bit/8bit.
// But It is definitely true that substring part can be represented as its parent's status 8bit/16bit, which is described as CharacterType.
auto& string = substringBase()->valueInternal();
if (string.is8Bit())
StringImpl::copyCharacters(buffer, string.characters8() + substringOffset(), length());
else
StringImpl::copyCharacters(buffer, string.characters16() + substringOffset(), length());
return;
}
resolveRopeInternalNoSubstring(buffer);
}
template<typename CharacterType>
void JSRopeString::resolveRopeInternalNoSubstring(CharacterType* buffer) const
{
for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i) {
if (fiber(i)->isRope()) {
resolveRopeSlowCase(buffer);
return;
}
}
CharacterType* position = buffer;
for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i) {
const StringImpl& fiberString = *fiber(i)->valueInternal().impl();
unsigned length = fiberString.length();
if (fiberString.is8Bit())
StringImpl::copyCharacters(position, fiberString.characters8(), length);
else
StringImpl::copyCharacters(position, fiberString.characters16(), length);
position += length;
}
ASSERT((buffer + length()) == position);
}
AtomString JSRopeString::resolveRopeToAtomString(JSGlobalObject* globalObject) const
{
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
auto convertToAtomString = [](const String& string) -> AtomString {
ASSERT(!string.impl() || string.impl()->isAtom());
return static_cast<AtomStringImpl*>(string.impl());
};
if (length() > maxLengthForOnStackResolve) {
scope.release();
return convertToAtomString(resolveRopeWithFunction(globalObject, [&] (Ref<StringImpl>&& newImpl) {
return AtomStringImpl::add(newImpl.ptr());
}));
}
if (is8Bit()) {
LChar buffer[maxLengthForOnStackResolve];
resolveRopeInternal(buffer);
convertToNonRope(AtomStringImpl::add(buffer, length()));
} else {
UChar buffer[maxLengthForOnStackResolve];
resolveRopeInternal(buffer);
convertToNonRope(AtomStringImpl::add(buffer, length()));
}
// If we resolved a string that didn't previously exist, notify the heap that we've grown.
if (valueInternal().impl()->hasOneRef())
vm.heap.reportExtraMemoryAllocated(valueInternal().impl()->cost());
return convertToAtomString(valueInternal());
}
inline void JSRopeString::convertToNonRope(String&& string) const
{
// Concurrent compiler threads can access String held by JSString. So we always emit
// store-store barrier here to ensure concurrent compiler threads see initialized String.
ASSERT(JSString::isRope());
WTF::storeStoreFence();
new (&uninitializedValueInternal()) String(WTFMove(string));
static_assert(sizeof(String) == sizeof(RefPtr<StringImpl>), "JSString's String initialization must be done in one pointer move.");
// We do not clear the trailing fibers and length information (fiber1 and fiber2) because we could be reading the length concurrently.
ASSERT(!JSString::isRope());
}
RefPtr<AtomStringImpl> JSRopeString::resolveRopeToExistingAtomString(JSGlobalObject* globalObject) const
{
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (length() > maxLengthForOnStackResolve) {
RefPtr<AtomStringImpl> existingAtomString;
resolveRopeWithFunction(globalObject, [&] (Ref<StringImpl>&& newImpl) -> Ref<StringImpl> {
existingAtomString = AtomStringImpl::lookUp(newImpl.ptr());
if (existingAtomString)
return Ref { *existingAtomString };
return WTFMove(newImpl);
});
RETURN_IF_EXCEPTION(scope, nullptr);
return existingAtomString;
}
if (is8Bit()) {
LChar buffer[maxLengthForOnStackResolve];
resolveRopeInternal(buffer);
if (RefPtr<AtomStringImpl> existingAtomString = AtomStringImpl::lookUp(buffer, length())) {
convertToNonRope(*existingAtomString);
return existingAtomString;
}
} else {
UChar buffer[maxLengthForOnStackResolve];
resolveRopeInternal(buffer);
if (RefPtr<AtomStringImpl> existingAtomString = AtomStringImpl::lookUp(buffer, length())) {
convertToNonRope(*existingAtomString);
return existingAtomString;
}
}
return nullptr;
}
template<typename Function>
const String& JSRopeString::resolveRopeWithFunction(JSGlobalObject* nullOrGlobalObjectForOOM, Function&& function) const
{
ASSERT(isRope());
VM& vm = this->vm();
if (isSubstring()) {
ASSERT(!substringBase()->isRope());
auto newImpl = substringBase()->valueInternal().substringSharingImpl(substringOffset(), length());
convertToNonRope(function(newImpl.releaseImpl().releaseNonNull()));
return valueInternal();
}
if (is8Bit()) {
LChar* buffer;
auto newImpl = StringImpl::tryCreateUninitialized(length(), buffer);
if (!newImpl) {
outOfMemory(nullOrGlobalObjectForOOM);
return nullString();
}
vm.heap.reportExtraMemoryAllocated(newImpl->cost());
resolveRopeInternalNoSubstring(buffer);
convertToNonRope(function(newImpl.releaseNonNull()));
return valueInternal();
}
UChar* buffer;
auto newImpl = StringImpl::tryCreateUninitialized(length(), buffer);
if (!newImpl) {
outOfMemory(nullOrGlobalObjectForOOM);
return nullString();
}
vm.heap.reportExtraMemoryAllocated(newImpl->cost());
resolveRopeInternalNoSubstring(buffer);
convertToNonRope(function(newImpl.releaseNonNull()));
return valueInternal();
}
const String& JSRopeString::resolveRope(JSGlobalObject* nullOrGlobalObjectForOOM) const
{
return resolveRopeWithFunction(nullOrGlobalObjectForOOM, [] (Ref<StringImpl>&& newImpl) {
return WTFMove(newImpl);
});
}
// Overview: These functions convert a JSString from holding a string in rope form
// 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
// in this fashion should minimize work queue size. (If we built the queue forwards
// we would likely have to place all of the constituent StringImpls into the
// Vector before performing any concatenation, but by working backwards we likely
// only fill the queue with the number of substrings at any given level in a
// rope-of-ropes.)
template<typename CharacterType>
void JSRopeString::resolveRopeSlowCase(CharacterType* buffer) const
{
CharacterType* position = buffer + length(); // We will be working backwards over the rope.
Vector<JSString*, 32, UnsafeVectorOverflow> workQueue; // These strings are kept alive by the parent rope, so using a Vector is OK.
for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i)
workQueue.append(fiber(i));
while (!workQueue.isEmpty()) {
JSString* currentFiber = workQueue.last();
workQueue.removeLast();
if (currentFiber->isRope()) {
JSRopeString* currentFiberAsRope = static_cast<JSRopeString*>(currentFiber);
if (currentFiberAsRope->isSubstring()) {
ASSERT(!currentFiberAsRope->substringBase()->isRope());
StringImpl* string = static_cast<StringImpl*>(
currentFiberAsRope->substringBase()->valueInternal().impl());
unsigned offset = currentFiberAsRope->substringOffset();
unsigned length = currentFiberAsRope->length();
position -= length;
if (string->is8Bit())
StringImpl::copyCharacters(position, string->characters8() + offset, length);
else
StringImpl::copyCharacters(position, string->characters16() + offset, length);
continue;
}
for (size_t i = 0; i < s_maxInternalRopeLength && currentFiberAsRope->fiber(i); ++i)
workQueue.append(currentFiberAsRope->fiber(i));
continue;
}
StringImpl* string = static_cast<StringImpl*>(currentFiber->valueInternal().impl());
unsigned length = string->length();
position -= length;
if (string->is8Bit())
StringImpl::copyCharacters(position, string->characters8(), length);
else
StringImpl::copyCharacters(position, string->characters16(), length);
}
ASSERT(buffer == position);
}
void JSRopeString::outOfMemory(JSGlobalObject* nullOrGlobalObjectForOOM) const
{
ASSERT(isRope());
if (nullOrGlobalObjectForOOM) {
VM& vm = nullOrGlobalObjectForOOM->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
throwOutOfMemoryError(nullOrGlobalObjectForOOM, scope);
}
}
JSValue JSString::toPrimitive(JSGlobalObject*, PreferredPrimitiveType) const
{
return const_cast<JSString*>(this);
}
double JSString::toNumber(JSGlobalObject* globalObject) const
{
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
StringView view = unsafeView(globalObject);
RETURN_IF_EXCEPTION(scope, 0);
return jsToNumber(view);
}
inline StringObject* StringObject::create(VM& vm, JSGlobalObject* globalObject, JSString* string)
{
StringObject* object = new (NotNull, allocateCell<StringObject>(vm)) StringObject(vm, globalObject->stringObjectStructure());
object->finishCreation(vm, string);
return object;
}
JSObject* JSString::toObject(JSGlobalObject* globalObject) const
{
return StringObject::create(globalObject->vm(), globalObject, const_cast<JSString*>(this));
}
JSValue JSString::toThis(JSCell* cell, JSGlobalObject* globalObject, ECMAMode ecmaMode)
{
if (ecmaMode.isStrict())
return cell;
return StringObject::create(globalObject->vm(), globalObject, asString(cell));
}
bool JSString::getStringPropertyDescriptor(JSGlobalObject* globalObject, PropertyName propertyName, PropertyDescriptor& descriptor)
{
VM& vm = globalObject->vm();
if (propertyName == vm.propertyNames->length) {
descriptor.setDescriptor(jsNumber(length()), PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
return true;
}
std::optional<uint32_t> index = parseIndex(propertyName);
if (index && index.value() < length()) {
descriptor.setDescriptor(getIndex(globalObject, index.value()), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
return true;
}
return false;
}
JSString* jsStringWithCacheSlowCase(VM& vm, StringImpl& stringImpl)
{
JSString* string = jsString(vm, String(stringImpl));
vm.lastCachedString.set(vm, string);
return string;
}
} // namespace JSC