Add API to generate and consume cached bytecode

https://bugs.webkit.org/show_bug.cgi?id=193401
<rdar://problem/47514099>

Reviewed by Keith Miller.

Add the `generateBytecode` and `generateModuleBytecode` functions to
generate serialized bytecode for a given `SourceCode`. These functions
will eagerly generate code for all the nested functions.

Additionally, update the API methods in JSScript to generate and use the
bytecode when the bytecodeCache path is provided.

* API/JSAPIGlobalObject.mm:
(JSC::JSAPIGlobalObject::moduleLoaderFetch):
* API/JSContext.mm:
(-[JSContext wrapperMap]):
* API/JSContextInternal.h:
* API/JSScript.mm:
(+[JSScript scriptWithSource:inVirtualMachine:]):
(+[JSScript scriptFromASCIIFile:inVirtualMachine:withCodeSigning:andBytecodeCache:]):
(-[JSScript dealloc]):
(-[JSScript readCache]):
(-[JSScript writeCache]):
(-[JSScript hash]):
(-[JSScript source]):
(-[JSScript cachedBytecode]):
(-[JSScript jsSourceCode:]):
* API/JSScriptInternal.h:
* API/JSScriptSourceProvider.h: Copied from Source/JavaScriptCore/API/JSScriptInternal.h.
(JSScriptSourceProvider::create):
(JSScriptSourceProvider::JSScriptSourceProvider):
* API/JSScriptSourceProvider.mm: Copied from Source/JavaScriptCore/API/JSScriptInternal.h.
(JSScriptSourceProvider::hash const):
(JSScriptSourceProvider::source const):
(JSScriptSourceProvider::cachedBytecode const):
* API/JSVirtualMachine.mm:
(-[JSVirtualMachine vm]):
* API/JSVirtualMachineInternal.h:
* API/tests/testapi.mm:
(testBytecodeCache):
(-[JSContextFileLoaderDelegate context:fetchModuleForIdentifier:withResolveHandler:andRejectHandler:]):
(testObjectiveCAPI):
* JavaScriptCore.xcodeproj/project.pbxproj:
* SourcesCocoa.txt:
* bytecode/UnlinkedFunctionExecutable.cpp:
(JSC::UnlinkedFunctionExecutable::unlinkedCodeBlockFor):
* bytecode/UnlinkedFunctionExecutable.h:
* parser/SourceCodeKey.h:
(JSC::SourceCodeKey::source const):
* parser/SourceProvider.h:
(JSC::CachedBytecode::CachedBytecode):
(JSC::CachedBytecode::operator=):
(JSC::CachedBytecode::data const):
(JSC::CachedBytecode::size const):
(JSC::CachedBytecode::owned const):
(JSC::CachedBytecode::~CachedBytecode):
(JSC::CachedBytecode::freeDataIfOwned):
(JSC::SourceProvider::cachedBytecode const):
* parser/UnlinkedSourceCode.h:
(JSC::UnlinkedSourceCode::provider const):
* runtime/CodeCache.cpp:
(JSC::generateUnlinkedCodeBlockForFunctions):
(JSC::writeCodeBlock):
(JSC::serializeBytecode):
* runtime/CodeCache.h:
(JSC::CodeCacheMap::fetchFromDiskImpl):
(JSC::CodeCacheMap::findCacheAndUpdateAge):
(JSC::generateUnlinkedCodeBlockImpl):
(JSC::generateUnlinkedCodeBlock):
* runtime/Completion.cpp:
(JSC::generateBytecode):
(JSC::generateModuleBytecode):
* runtime/Completion.h:
* runtime/Options.cpp:
(JSC::recomputeDependentOptions):


git-svn-id: http://svn.webkit.org/repository/webkit/trunk@240511 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Author: [email protected]

Source/JavaScriptCore/API/JSAPIGlobalObject.mm

@@ -164,7 +164,6 @@
     auto deferredPromise = Strong<JSInternalPromiseDeferred>(vm, deferred);
     auto strongKey = Strong<JSString>(vm, jsSecureCast<JSString*>(vm, key));
     auto* resolve = JSNativeStdFunction::create(vm, globalObject, 1, "resolve", [=] (ExecState* exec) {
-        VM& vm = exec->vm();
         // This captures the globalObject but that's ok because our structure keeps it alive anyway.
         JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(globalObject->globalExec())];
         id script = valueToObject(context, toRef(exec, exec->argument(0)));
@@ -176,8 +175,7 @@
             return encodedJSUndefined();
         }
 
-        const String& source = getJSScriptSourceCode(static_cast<JSScript *>(script));
-        args.append(JSSourceCode::create(vm, makeSource(source, SourceOrigin(moduleKey.string()), URL({ }, moduleKey.string()), TextPosition(), JSC::SourceProviderSourceType::Module)));
+        args.append([static_cast<JSScript *>(script) jsSourceCode:moduleKey]);
         call(exec, deferredPromise->JSPromiseDeferred::resolve(), args, "This should never be seen...");
         return encodedJSUndefined();
     });

Source/JavaScriptCore/API/JSContext.mm

@@ -34,7 +34,6 @@
 #import "JSGlobalObject.h"
 #import "JSInternalPromise.h"
 #import "JSModuleLoader.h"
-#import "JSScriptInternal.h"
 #import "JSValueInternal.h"
 #import "JSVirtualMachineInternal.h"
 #import "JSWrapperMap.h"
@@ -135,11 +134,6 @@ - (JSValue *)exception
     return [JSValue valueWithJSValueRef:toRef(m_exception.get()) inContext:self];
 }
 
-- (JSWrapperMap *)wrapperMap
-{
-    return toJS(m_context)->lexicalGlobalObject()->wrapperMap();
-}
-
 - (JSValue *)globalObject
 {
     return [JSValue valueWithJSValueRef:JSContextGetGlobalObject(m_context) inContext:self];
@@ -332,6 +326,11 @@ - (JSValue *)wrapperForObjCObject:(id)object
     return [[self wrapperMap] jsWrapperForObject:object inContext:self];
 }
 
+- (JSWrapperMap *)wrapperMap
+{
+    return toJS(m_context)->lexicalGlobalObject()->wrapperMap();
+}
+
 - (JSValue *)wrapperForJSObject:(JSValueRef)value
 {
     JSC::JSLockHolder locker(toJS(m_context));

Source/JavaScriptCore/API/JSContextInternal.h

@@ -51,6 +51,7 @@ struct CallbackData {
 - (void)beginCallbackWithData:(CallbackData *)callbackData calleeValue:(JSValueRef)calleeValue thisValue:(JSValueRef)thisValue argumentCount:(size_t)argumentCount arguments:(const JSValueRef *)arguments;
 - (void)endCallbackWithData:(CallbackData *)callbackData;
 
+- (JSWrapperMap *)wrapperMap;
 - (JSValue *)wrapperForObjCObject:(id)object;
 - (JSValue *)wrapperForJSObject:(JSValueRef)value;
 

Source/JavaScriptCore/API/JSScript.mm

@@ -27,21 +27,32 @@
 #import "JSScriptInternal.h"
 
 #import "APICast.h"
+#import "Identifier.h"
 #import "JSContextInternal.h"
+#import "JSScriptSourceProvider.h"
+#import "JSSourceCode.h"
 #import "JSValuePrivate.h"
+#import "JSVirtualMachineInternal.h"
+#import "ParserError.h"
 #import "Symbol.h"
+#include <sys/stat.h>
 
 #if JSC_OBJC_API_ENABLED
 
 @implementation JSScript {
+    __weak JSVirtualMachine* m_virtualMachine;
     String m_source;
+    NSURL* m_cachePath;
+    JSC::CachedBytecode m_cachedBytecode;
+    JSC::Strong<JSC::JSSourceCode> m_jsSourceCode;
+    UniquedStringImpl* m_moduleKey;
 }
 
 + (instancetype)scriptWithSource:(NSString *)source inVirtualMachine:(JSVirtualMachine *)vm
 {
-    UNUSED_PARAM(vm);
-    JSScript *result = [[JSScript alloc] init];
+    JSScript *result = [[[JSScript alloc] init] autorelease];
     result->m_source = source;
+    result->m_virtualMachine = vm;
     return result;
 }
 
@@ -81,9 +92,6 @@ + (instancetype)scriptFromASCIIFile:(NSURL *)filePath inVirtualMachine:(JSVirtua
 {
     // FIXME: This should check codeSigning.
     UNUSED_PARAM(codeSigningPath);
-    // FIXME: This should actually cache bytecode.
-    UNUSED_PARAM(cachePath);
-    UNUSED_PARAM(vm);
     URL filePathURL([filePath absoluteURL]);
     if (!filePathURL.isLocalFile())
         return nil;
@@ -95,8 +103,11 @@ + (instancetype)scriptFromASCIIFile:(NSURL *)filePath inVirtualMachine:(JSVirtua
     if (!charactersAreAllASCII(buffer.data(), buffer.size()))
         return nil;
 
-    JSScript *result = [[JSScript alloc] init];
+    JSScript *result = [[[JSScript alloc] init] autorelease];
+    result->m_virtualMachine = vm;
     result->m_source = String::fromUTF8WithLatin1Fallback(buffer.data(), buffer.size());
+    result->m_cachePath = cachePath;
+    [result readCache];
     return result;
 }
 
@@ -105,7 +116,95 @@ + (instancetype)scriptFromUTF8File:(NSURL *)filePath inVirtualMachine:(JSVirtual
     return [JSScript scriptFromASCIIFile:filePath inVirtualMachine:vm withCodeSigning:codeSigningPath andBytecodeCache:cachePath];
 }
 
-const String& getJSScriptSourceCode(JSScript *module) { return module->m_source; }
+- (void)dealloc
+{
+    if (m_cachedBytecode.size() && !m_cachedBytecode.owned())
+        munmap(const_cast<void*>(m_cachedBytecode.data()), m_cachedBytecode.size());
+    [super dealloc];
+}
+
+- (void)readCache
+{
+    if (!m_cachePath)
+        return;
+
+    int fd = open(m_cachePath.path.UTF8String, O_RDONLY);
+    if (fd == -1)
+        return;
+
+    int rc = flock(fd, LOCK_SH | LOCK_NB);
+    if (rc) {
+        close(fd);
+        return;
+    }
+
+    struct stat sb;
+    int res = fstat(fd, &sb);
+    size_t size = static_cast<size_t>(sb.st_size);
+    if (res || !size) {
+        close(fd);
+        return;
+    }
+
+    void* buffer = mmap(nullptr, size, PROT_READ, MAP_PRIVATE, fd, 0);
+    close(fd);
+
+    m_cachedBytecode = JSC::CachedBytecode { buffer, size };
+}
+
+- (void)writeCache
+{
+    if (m_cachedBytecode.size() || !m_cachePath)
+        return;
+
+    JSC::ParserError error;
+    m_cachedBytecode = JSC::generateModuleBytecode(m_virtualMachine.vm, m_jsSourceCode->sourceCode(), error);
+    if (error.isValid())
+        return;
+    int fd = open(m_cachePath.path.UTF8String, O_CREAT | O_WRONLY, 0666);
+    if (fd == -1)
+        return;
+    int rc = flock(fd, LOCK_EX | LOCK_NB);
+    if (!rc)
+        write(fd, m_cachedBytecode.data(), m_cachedBytecode.size());
+    close(fd);
+}
+
+@end
+
+@implementation JSScript(Internal)
+
+- (unsigned)hash
+{
+    return m_source.hash();
+}
+
+- (const String&)source
+{
+    return m_source;
+}
+
+- (const JSC::CachedBytecode*)cachedBytecode
+{
+    return &m_cachedBytecode;
+}
+
+- (JSC::JSSourceCode*)jsSourceCode:(const JSC::Identifier&)moduleKey
+{
+    if (m_jsSourceCode) {
+        ASSERT(moduleKey.impl() == m_moduleKey);
+        return m_jsSourceCode.get();
+    }
+
+    JSC::VM& vm = m_virtualMachine.vm;
+    TextPosition startPosition { };
+    Ref<JSScriptSourceProvider> sourceProvider = JSScriptSourceProvider::create(self, JSC::SourceOrigin(moduleKey.string()), URL({ }, moduleKey.string()), TextPosition(), JSC::SourceProviderSourceType::Module);
+    JSC::SourceCode sourceCode(WTFMove(sourceProvider), startPosition.m_line.oneBasedInt(), startPosition.m_column.oneBasedInt());
+    JSC::JSSourceCode* jsSourceCode = JSC::JSSourceCode::create(vm, WTFMove(sourceCode));
+    m_jsSourceCode.set(vm, jsSourceCode);
+    [self writeCache];
+    return jsSourceCode;
+}
 
 @end
 

Source/JavaScriptCore/API/JSScriptInternal.h

@@ -28,6 +28,29 @@
 #import "JSScript.h"
 #import "SourceCode.h"
 
-OBJC_CLASS JSScript;
+#if JSC_OBJC_API_ENABLED
 
-const String& getJSScriptSourceCode(JSScript *);
+NS_ASSUME_NONNULL_BEGIN
+
+namespace JSC {
+class CachedBytecode;
+class Identifier;
+class JSSourceCode;
+};
+
+namespace WTF {
+class String;
+};
+
+@interface JSScript(Internal)
+
+- (unsigned)hash;
+- (const WTF::String&)source;
+- (const JSC::CachedBytecode*)cachedBytecode;
+- (JSC::JSSourceCode*)jsSourceCode:(const JSC::Identifier&)moduleKey;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // JSC_OBJC_API_ENABLED

Source/JavaScriptCore/API/JSScriptSourceProvider.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2019 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if JSC_OBJC_API_ENABLED
+
+#import "SourceProvider.h"
+
+@class JSScript;
+
+class JSScriptSourceProvider : public JSC::SourceProvider {
+public:
+    template<typename... Args>
+    static Ref<JSScriptSourceProvider> create(JSScript *script, Args&&... args)
+    {
+        return adoptRef(*new JSScriptSourceProvider(script, std::forward<Args>(args)...));
+    }
+
+    unsigned hash() const override;
+    StringView source() const override;
+    const JSC::CachedBytecode* cachedBytecode() const override;
+
+private:
+    template<typename... Args>
+    JSScriptSourceProvider(JSScript *script, Args&&... args)
+        : SourceProvider(std::forward<Args>(args)...)
+        , m_script(script)
+    { }
+
+    RetainPtr<JSScript> m_script;
+};
+
+#endif // JSC_OBJC_API_ENABLED

Source/JavaScriptCore/API/JSScriptSourceProvider.mm

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2019 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import "config.h"
+#import "JSScriptSourceProvider.h"
+
+#if JSC_OBJC_API_ENABLED
+
+#import "JSScriptInternal.h"
+
+unsigned JSScriptSourceProvider::hash() const
+{
+    return [m_script.get() hash];
+}
+
+StringView JSScriptSourceProvider::source() const
+{
+    return [m_script.get() source];
+}
+
+const JSC::CachedBytecode* JSScriptSourceProvider::cachedBytecode() const
+{
+    return [m_script.get() cachedBytecode];
+}
+
+#endif // JSC_OBJC_API_ENABLED

Source/JavaScriptCore/API/JSVirtualMachine.mm

@@ -297,6 +297,11 @@ + (NSUInteger)setNumberOfFTLCompilerThreads:(NSUInteger)numberOfThreads
 
 #endif // ENABLE(DFG_JIT)
 
+- (JSC::VM&)vm
+{
+    return *toJS(m_group);
+}
+
 @end
 
 static void scanExternalObjectGraph(JSC::VM& vm, JSC::SlotVisitor& visitor, void* root, bool lockAcquired)

Source/JavaScriptCore/API/JSVirtualMachineInternal.h

@@ -46,6 +46,8 @@ JSContextGroupRef getGroupFromVirtualMachine(JSVirtualMachine *);
 
 - (JSContext *)contextForGlobalContextRef:(JSGlobalContextRef)globalContext;
 - (void)addContext:(JSContext *)wrapper forGlobalContextRef:(JSGlobalContextRef)globalContext;
+- (JSC::VM&)vm;
+
 @end
 
 #endif // defined(__OBJC__)