Add CatchScope and force all exception checks to be via ThrowScope or CatchScope.
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSString.cpp
1 /*
2  *  Copyright (C) 1999-2002 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2004, 2007-2008, 2015-2016 Apple Inc. All rights reserved.
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Library General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Library General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Library General Public License
17  *  along with this library; see the file COPYING.LIB.  If not, write to
18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  *  Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #include "config.h"
24 #include "JSString.h"
25
26 #include "JSGlobalObject.h"
27 #include "JSGlobalObjectFunctions.h"
28 #include "JSObject.h"
29 #include "JSCInlines.h"
30 #include "StringObject.h"
31 #include "StringPrototype.h"
32 #include "StrongInlines.h"
33
34 namespace JSC {
35     
36 const ClassInfo JSString::s_info = { "string", 0, 0, CREATE_METHOD_TABLE(JSString) };
37
38 Structure* JSString::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue proto)
39 {
40     return Structure::create(vm, globalObject, proto, TypeInfo(StringType, StructureFlags), info());
41 }
42
43 void JSRopeString::RopeBuilder::expand()
44 {
45     ASSERT(m_index == JSRopeString::s_maxInternalRopeLength);
46     JSString* jsString = m_jsString;
47     RELEASE_ASSERT(jsString);
48     m_jsString = jsStringBuilder(&m_vm);
49     m_index = 0;
50     append(jsString);
51 }
52
53 void JSString::destroy(JSCell* cell)
54 {
55     JSString* thisObject = static_cast<JSString*>(cell);
56     thisObject->JSString::~JSString();
57 }
58
59 void JSString::dumpToStream(const JSCell* cell, PrintStream& out)
60 {
61     const JSString* thisObject = jsCast<const JSString*>(cell);
62     out.printf("<%p, %s, [%u], ", thisObject, thisObject->className(), thisObject->length());
63     if (thisObject->isRope())
64         out.printf("[rope]");
65     else {
66         WTF::StringImpl* ourImpl = thisObject->m_value.impl();
67         if (ourImpl->is8Bit())
68             out.printf("[8 %p]", ourImpl->characters8());
69         else
70             out.printf("[16 %p]", ourImpl->characters16());
71     }
72     out.printf(">");
73 }
74
75 bool JSString::equalSlowCase(ExecState* exec, JSString* other) const
76 {
77     VM& vm = exec->vm();
78     auto scope = DECLARE_THROW_SCOPE(vm);
79     String str1 = value(exec);
80     String str2 = other->value(exec);
81     if (UNLIKELY(scope.exception()))
82         return false;
83     return WTF::equal(*str1.impl(), *str2.impl());
84 }
85
86 size_t JSString::estimatedSize(JSCell* cell)
87 {
88     JSString* thisObject = jsCast<JSString*>(cell);
89     if (thisObject->isRope())
90         return Base::estimatedSize(cell);
91     return Base::estimatedSize(cell) + thisObject->m_value.impl()->costDuringGC();
92 }
93
94 void JSString::visitChildren(JSCell* cell, SlotVisitor& visitor)
95 {
96     JSString* thisObject = jsCast<JSString*>(cell);
97     Base::visitChildren(thisObject, visitor);
98     
99     if (thisObject->isRope())
100         static_cast<JSRopeString*>(thisObject)->visitFibers(visitor);
101     else {
102         StringImpl* impl = thisObject->m_value.impl();
103         ASSERT(impl);
104         visitor.reportExtraMemoryVisited(impl->costDuringGC());
105     }
106 }
107
108 void JSRopeString::visitFibers(SlotVisitor& visitor)
109 {
110     if (isSubstring()) {
111         visitor.append(&substringBase());
112         return;
113     }
114     for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i)
115         visitor.append(&fiber(i));
116 }
117
118 static const unsigned maxLengthForOnStackResolve = 2048;
119
120 void JSRopeString::resolveRopeInternal8(LChar* buffer) const
121 {
122     if (isSubstring()) {
123         StringImpl::copyChars(
124             buffer, substringBase()->m_value.characters8() + substringOffset(), m_length);
125         return;
126     }
127     
128     resolveRopeInternal8NoSubstring(buffer);
129 }
130
131 void JSRopeString::resolveRopeInternal8NoSubstring(LChar* buffer) const
132 {
133     for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i) {
134         if (fiber(i)->isRope()) {
135             resolveRopeSlowCase8(buffer);
136             return;
137         }
138     }
139
140     LChar* position = buffer;
141     for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i) {
142         const StringImpl& fiberString = *fiber(i)->m_value.impl();
143         unsigned length = fiberString.length();
144         StringImpl::copyChars(position, fiberString.characters8(), length);
145         position += length;
146     }
147     ASSERT((buffer + m_length) == position);
148 }
149
150 void JSRopeString::resolveRopeInternal16(UChar* buffer) const
151 {
152     if (isSubstring()) {
153         StringImpl::copyChars(
154             buffer, substringBase()->m_value.characters16() + substringOffset(), m_length);
155         return;
156     }
157     
158     resolveRopeInternal16NoSubstring(buffer);
159 }
160
161 void JSRopeString::resolveRopeInternal16NoSubstring(UChar* buffer) const
162 {
163     for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i) {
164         if (fiber(i)->isRope()) {
165             resolveRopeSlowCase(buffer);
166             return;
167         }
168     }
169
170     UChar* position = buffer;
171     for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i) {
172         const StringImpl& fiberString = *fiber(i)->m_value.impl();
173         unsigned length = fiberString.length();
174         if (fiberString.is8Bit())
175             StringImpl::copyChars(position, fiberString.characters8(), length);
176         else
177             StringImpl::copyChars(position, fiberString.characters16(), length);
178         position += length;
179     }
180     ASSERT((buffer + m_length) == position);
181 }
182
183 void JSRopeString::resolveRopeToAtomicString(ExecState* exec) const
184 {
185     if (m_length > maxLengthForOnStackResolve) {
186         resolveRope(exec);
187         m_value = AtomicString(m_value);
188         setIs8Bit(m_value.impl()->is8Bit());
189         return;
190     }
191
192     if (is8Bit()) {
193         LChar buffer[maxLengthForOnStackResolve];
194         resolveRopeInternal8(buffer);
195         m_value = AtomicString(buffer, m_length);
196         setIs8Bit(m_value.impl()->is8Bit());
197     } else {
198         UChar buffer[maxLengthForOnStackResolve];
199         resolveRopeInternal16(buffer);
200         m_value = AtomicString(buffer, m_length);
201         setIs8Bit(m_value.impl()->is8Bit());
202     }
203
204     clearFibers();
205
206     // If we resolved a string that didn't previously exist, notify the heap that we've grown.
207     if (m_value.impl()->hasOneRef())
208         Heap::heap(this)->reportExtraMemoryAllocated(m_value.impl()->cost());
209 }
210
211 void JSRopeString::clearFibers() const
212 {
213     for (size_t i = 0; i < s_maxInternalRopeLength; ++i)
214         u[i].number = 0;
215 }
216
217 RefPtr<AtomicStringImpl> JSRopeString::resolveRopeToExistingAtomicString(ExecState* exec) const
218 {
219     if (m_length > maxLengthForOnStackResolve) {
220         resolveRope(exec);
221         if (RefPtr<AtomicStringImpl> existingAtomicString = AtomicStringImpl::lookUp(m_value.impl())) {
222             m_value = *existingAtomicString;
223             setIs8Bit(m_value.impl()->is8Bit());
224             clearFibers();
225             return existingAtomicString;
226         }
227         return nullptr;
228     }
229     
230     if (is8Bit()) {
231         LChar buffer[maxLengthForOnStackResolve];
232         resolveRopeInternal8(buffer);
233         if (RefPtr<AtomicStringImpl> existingAtomicString = AtomicStringImpl::lookUp(buffer, m_length)) {
234             m_value = *existingAtomicString;
235             setIs8Bit(m_value.impl()->is8Bit());
236             clearFibers();
237             return existingAtomicString;
238         }
239     } else {
240         UChar buffer[maxLengthForOnStackResolve];
241         resolveRopeInternal16(buffer);
242         if (RefPtr<AtomicStringImpl> existingAtomicString = AtomicStringImpl::lookUp(buffer, m_length)) {
243             m_value = *existingAtomicString;
244             setIs8Bit(m_value.impl()->is8Bit());
245             clearFibers();
246             return existingAtomicString;
247         }
248     }
249
250     return nullptr;
251 }
252
253 void JSRopeString::resolveRope(ExecState* exec) const
254 {
255     ASSERT(isRope());
256     
257     if (isSubstring()) {
258         ASSERT(!substringBase()->isRope());
259         m_value = substringBase()->m_value.substringSharingImpl(substringOffset(), m_length);
260         substringBase().clear();
261         return;
262     }
263     
264     if (is8Bit()) {
265         LChar* buffer;
266         if (auto newImpl = StringImpl::tryCreateUninitialized(m_length, buffer)) {
267             Heap::heap(this)->reportExtraMemoryAllocated(newImpl->cost());
268             m_value = WTFMove(newImpl);
269         } else {
270             outOfMemory(exec);
271             return;
272         }
273         resolveRopeInternal8NoSubstring(buffer);
274         clearFibers();
275         ASSERT(!isRope());
276         return;
277     }
278
279     UChar* buffer;
280     if (auto newImpl = StringImpl::tryCreateUninitialized(m_length, buffer)) {
281         Heap::heap(this)->reportExtraMemoryAllocated(newImpl->cost());
282         m_value = WTFMove(newImpl);
283     } else {
284         outOfMemory(exec);
285         return;
286     }
287
288     resolveRopeInternal16NoSubstring(buffer);
289     clearFibers();
290     ASSERT(!isRope());
291 }
292
293 // Overview: These functions convert a JSString from holding a string in rope form
294 // down to a simple String representation. It does so by building up the string
295 // backwards, since we want to avoid recursion, we expect that the tree structure
296 // representing the rope is likely imbalanced with more nodes down the left side
297 // (since appending to the string is likely more common) - and as such resolving
298 // in this fashion should minimize work queue size.  (If we built the queue forwards
299 // we would likely have to place all of the constituent StringImpls into the
300 // Vector before performing any concatenation, but by working backwards we likely
301 // only fill the queue with the number of substrings at any given level in a
302 // rope-of-ropes.)    
303 void JSRopeString::resolveRopeSlowCase8(LChar* buffer) const
304 {
305     LChar* position = buffer + m_length; // We will be working backwards over the rope.
306     Vector<JSString*, 32, UnsafeVectorOverflow> workQueue; // Putting strings into a Vector is only OK because there are no GC points in this method.
307     
308     for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i)
309         workQueue.append(fiber(i).get());
310
311     while (!workQueue.isEmpty()) {
312         JSString* currentFiber = workQueue.last();
313         workQueue.removeLast();
314
315         const LChar* characters;
316         
317         if (currentFiber->isRope()) {
318             JSRopeString* currentFiberAsRope = static_cast<JSRopeString*>(currentFiber);
319             if (!currentFiberAsRope->isSubstring()) {
320                 for (size_t i = 0; i < s_maxInternalRopeLength && currentFiberAsRope->fiber(i); ++i)
321                     workQueue.append(currentFiberAsRope->fiber(i).get());
322                 continue;
323             }
324             ASSERT(!currentFiberAsRope->substringBase()->isRope());
325             characters =
326                 currentFiberAsRope->substringBase()->m_value.characters8() +
327                 currentFiberAsRope->substringOffset();
328         } else
329             characters = currentFiber->m_value.characters8();
330         
331         unsigned length = currentFiber->length();
332         position -= length;
333         StringImpl::copyChars(position, characters, length);
334     }
335
336     ASSERT(buffer == position);
337 }
338
339 void JSRopeString::resolveRopeSlowCase(UChar* buffer) const
340 {
341     UChar* position = buffer + m_length; // We will be working backwards over the rope.
342     Vector<JSString*, 32, UnsafeVectorOverflow> workQueue; // These strings are kept alive by the parent rope, so using a Vector is OK.
343
344     for (size_t i = 0; i < s_maxInternalRopeLength && fiber(i); ++i)
345         workQueue.append(fiber(i).get());
346
347     while (!workQueue.isEmpty()) {
348         JSString* currentFiber = workQueue.last();
349         workQueue.removeLast();
350
351         if (currentFiber->isRope()) {
352             JSRopeString* currentFiberAsRope = static_cast<JSRopeString*>(currentFiber);
353             if (currentFiberAsRope->isSubstring()) {
354                 ASSERT(!currentFiberAsRope->substringBase()->isRope());
355                 StringImpl* string = static_cast<StringImpl*>(
356                     currentFiberAsRope->substringBase()->m_value.impl());
357                 unsigned offset = currentFiberAsRope->substringOffset();
358                 unsigned length = currentFiberAsRope->length();
359                 position -= length;
360                 if (string->is8Bit())
361                     StringImpl::copyChars(position, string->characters8() + offset, length);
362                 else
363                     StringImpl::copyChars(position, string->characters16() + offset, length);
364                 continue;
365             }
366             for (size_t i = 0; i < s_maxInternalRopeLength && currentFiberAsRope->fiber(i); ++i)
367                 workQueue.append(currentFiberAsRope->fiber(i).get());
368             continue;
369         }
370
371         StringImpl* string = static_cast<StringImpl*>(currentFiber->m_value.impl());
372         unsigned length = string->length();
373         position -= length;
374         if (string->is8Bit())
375             StringImpl::copyChars(position, string->characters8(), length);
376         else
377             StringImpl::copyChars(position, string->characters16(), length);
378     }
379
380     ASSERT(buffer == position);
381 }
382
383 void JSRopeString::outOfMemory(ExecState* exec) const
384 {
385     VM& vm = exec->vm();
386     auto scope = DECLARE_THROW_SCOPE(vm);
387
388     clearFibers();
389     ASSERT(isRope());
390     ASSERT(m_value.isNull());
391     if (exec)
392         throwOutOfMemoryError(exec, scope);
393 }
394
395 JSValue JSString::toPrimitive(ExecState*, PreferredPrimitiveType) const
396 {
397     return const_cast<JSString*>(this);
398 }
399
400 bool JSString::getPrimitiveNumber(ExecState* exec, double& number, JSValue& result) const
401 {
402     result = this;
403     number = jsToNumber(unsafeView(*exec));
404     return false;
405 }
406
407 double JSString::toNumber(ExecState* exec) const
408 {
409     return jsToNumber(unsafeView(*exec));
410 }
411
412 inline StringObject* StringObject::create(VM& vm, JSGlobalObject* globalObject, JSString* string)
413 {
414     StringObject* object = new (NotNull, allocateCell<StringObject>(vm.heap)) StringObject(vm, globalObject->stringObjectStructure());
415     object->finishCreation(vm, string);
416     return object;
417 }
418
419 JSObject* JSString::toObject(ExecState* exec, JSGlobalObject* globalObject) const
420 {
421     return StringObject::create(exec->vm(), globalObject, const_cast<JSString*>(this));
422 }
423
424 JSValue JSString::toThis(JSCell* cell, ExecState* exec, ECMAMode ecmaMode)
425 {
426     if (ecmaMode == StrictMode)
427         return cell;
428     return StringObject::create(exec->vm(), exec->lexicalGlobalObject(), jsCast<JSString*>(cell));
429 }
430
431 bool JSString::getStringPropertyDescriptor(ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
432 {
433     if (propertyName == exec->propertyNames().length) {
434         descriptor.setDescriptor(jsNumber(m_length), DontEnum | DontDelete | ReadOnly);
435         return true;
436     }
437     
438     Optional<uint32_t> index = parseIndex(propertyName);
439     if (index && index.value() < m_length) {
440         descriptor.setDescriptor(getIndex(exec, index.value()), DontDelete | ReadOnly);
441         return true;
442     }
443     
444     return false;
445 }
446
447 JSString* jsStringWithCacheSlowCase(VM& vm, StringImpl& stringImpl)
448 {
449     if (JSString* string = vm.stringCache.get(&stringImpl))
450         return string;
451
452     JSString* string = jsString(&vm, String(stringImpl));
453     vm.lastCachedString.set(vm, string);
454     return string;
455 }
456
457 } // namespace JSC