corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 1899090 - Part 9: Rename *IncrementalEncoding public API to *CollectDelazifications. r=nbp

Browse Source 
Differential Revision: https://phabricator.services.mozilla.com/D230385
This commit is contained in:
Tooru Fujisawa
2024-12-04 00:54:46 +00:00
parent 7941811545
commit d0e537de50
8 changed files with 103 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
dom/base/JSExecutionUtils.cpp
View File

@@ -16,7 +16,7 @@
#include <utility> // std::move
#include "ErrorList.h" // NS_ERROR_OUT_OF_MEMORY, NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW, NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW_UNCATCHABLE
#include "js/CompilationAndEvaluation.h" // JS::UpdateDebugMetadata
#include "js/experimental/JSStencil.h" // JS::StartIncrementalEncoding
#include "js/experimental/JSStencil.h" // JS::Stencil, JS::CompileGlobalScriptToStencil
#include "js/SourceText.h" // JS::SourceText, JS::SourceOwnership
#include "jsapi.h" // JS_IsExceptionPending
#include "nsTPromiseFlatString.h" // PromiseFlatString

4
dom/script/ModuleLoader.cpp
View File

@@ -236,7 +236,7 @@ nsresult ModuleLoader::CompileJavaScriptModule(
if (aRequest->IsTextSource() &&
aRequest->PassedConditionForBytecodeEncoding()) {
bool alreadyStarted;
if (!JS::StartIncrementalEncoding(aCx, aModuleOut, stencil,
if (!JS::StartCollectingDelazifications(aCx, aModuleOut, stencil,
alreadyStarted)) {
return NS_ERROR_FAILURE;
}
@@ -284,7 +284,7 @@ nsresult ModuleLoader::CompileJavaScriptModule(
if (aRequest->IsTextSource() &&
aRequest->PassedConditionForBytecodeEncoding()) {
bool alreadyStarted;
if (!JS::StartIncrementalEncoding(aCx, aModuleOut, stencil,
if (!JS::StartCollectingDelazifications(aCx, aModuleOut, stencil,
alreadyStarted)) {
return NS_ERROR_FAILURE;
}

32
dom/script/ScriptLoader.cpp
View File

@@ -21,7 +21,7 @@
#include "js/CompilationAndEvaluation.h"
#include "js/CompileOptions.h" // JS::CompileOptions, JS::OwningCompileOptions, JS::DecodeOptions, JS::OwningDecodeOptions, JS::DelazificationOption
#include "js/ContextOptions.h" // JS::ContextOptionsRef
#include "js/experimental/JSStencil.h" // JS::Stencil, JS::InstantiationStorage
#include "js/experimental/JSStencil.h" // JS::Stencil, JS::InstantiationStorage, JS::StartCollectingDelazifications, JS::FinishCollectingDelazifications, JS::AbortCollectingDelazifications
#include "js/experimental/CompileScript.h" // JS::FrontendContext, JS::NewFrontendContext, JS::DestroyFrontendContext, JS::SetNativeStackQuota, JS::ThreadStackQuotaForSize, JS::CompilationStorage, JS::CompileGlobalScriptToStencil, JS::CompileModuleScriptToStencil, JS::DecodeStencil, JS::PrepareForInstantiate
#include "js/loader/ScriptLoadRequest.h"
#include "ScriptCompression.h"
@@ -2747,7 +2747,7 @@ static void Decode(JSContext* aCx, JS::CompileOptions& aCompileOptions,
static void InstantiateStencil(
JSContext* aCx, JS::CompileOptions& aCompileOptions, JS::Stencil* aStencil,
JS::MutableHandle<JSScript*> aScript,
bool& incrementalEncodingAlreadyStarted,
bool& aCollectingDelazificationsAlreadyStarted,
JS::Handle<JS::Value> aDebuggerPrivateValue,
JS::Handle<JSScript*> aDebuggerIntroductionScript, ErrorResult& aRv,
bool aEncodeBytecode = false,
@@ -2762,8 +2762,8 @@ static void InstantiateStencil(
}
if (aEncodeBytecode) {
if (!JS::StartIncrementalEncoding(aCx, script, aStencil,
incrementalEncodingAlreadyStarted)) {
if (!JS::StartCollectingDelazifications(
aCx, script, aStencil, aCollectingDelazificationsAlreadyStarted)) {
aRv.NoteJSContextException(aCx);
return;
}
@@ -2903,12 +2903,12 @@ void ScriptLoader::InstantiateClassicScriptFromCachedStencil(
JS::MutableHandle<JSScript*> aScript,
JS::Handle<JS::Value> aDebuggerPrivateValue,
JS::Handle<JSScript*> aDebuggerIntroductionScript, ErrorResult& aRv) {
bool incrementalEncodingAlreadyStarted = false;
bool collectingDelazificationsAlreadyStarted = false;
InstantiateStencil(aCx, aCompileOptions, aStencil, aScript,
incrementalEncodingAlreadyStarted, aDebuggerPrivateValue,
aDebuggerIntroductionScript, aRv,
collectingDelazificationsAlreadyStarted,
aDebuggerPrivateValue, aDebuggerIntroductionScript, aRv,
/* aEncodeBytecode */ true);
if (incrementalEncodingAlreadyStarted) {
if (collectingDelazificationsAlreadyStarted) {
aRequest->MarkSkippedBytecodeEncoding();
}
}
@@ -3286,14 +3286,14 @@ void ScriptLoader::EncodeRequestBytecode(JSContext* aCx,
aRequest->mScriptForBytecodeEncoding = nullptr;
ModuleScript* moduleScript = aRequest->AsModuleRequest()->mModuleScript;
JS::Rooted<JSObject*> module(aCx, moduleScript->ModuleRecord());
result =
JS::FinishIncrementalEncoding(aCx, module, aRequest->SRIAndBytecode());
result = JS::FinishCollectingDelazifications(aCx, module,
aRequest->SRIAndBytecode());
} else if (mCache) {
RefPtr<JS::Stencil> stencil;
JS::Rooted<JSScript*> script(aCx, aRequest->mScriptForBytecodeEncoding);
aRequest->mScriptForBytecodeEncoding = nullptr;
result =
JS::FinishIncrementalEncoding(aCx, script, getter_AddRefs(stencil));
result = JS::FinishCollectingDelazifications(aCx, script,
getter_AddRefs(stencil));
if (result) {
aRequest->SetStencil(stencil.forget());
bytecodeFailed.release();
@@ -3302,8 +3302,8 @@ void ScriptLoader::EncodeRequestBytecode(JSContext* aCx,
// TODO: Bytecode encoding for script, at different timing.
} else {
JS::Rooted<JSScript*> script(aCx, aRequest->mScriptForBytecodeEncoding);
result =
JS::FinishIncrementalEncoding(aCx, script, aRequest->SRIAndBytecode());
result = JS::FinishCollectingDelazifications(aCx, script,
aRequest->SRIAndBytecode());
aRequest->mScriptForBytecodeEncoding = nullptr;
}
if (!result) {
@@ -3400,12 +3400,12 @@ void ScriptLoader::GiveUpBytecodeEncoding() {
if (request->IsModuleRequest()) {
ModuleScript* moduleScript = request->AsModuleRequest()->mModuleScript;
JS::Rooted<JSObject*> module(aes->cx(), moduleScript->ModuleRecord());
JS::AbortIncrementalEncoding(module);
JS::AbortCollectingDelazifications(module);
} else {
JS::Rooted<JSScript*> script(aes->cx(),
request->mScriptForBytecodeEncoding);
request->mScriptForBytecodeEncoding = nullptr;
JS::AbortIncrementalEncoding(script);
JS::AbortCollectingDelazifications(script);
}
}

54
js/public/Transcoding.h
View File

@@ -86,60 +86,6 @@ inline bool IsTranscodingBytecodeAligned(const void* offset) {
return IsTranscodingBytecodeOffsetAligned(size_t(offset));
}
// Finish incremental encoding started by JS::StartIncrementalEncoding.
//
// * Regular script case
// the |script| argument must be the top-level script returned from
// |JS::InstantiateGlobalStencil| with the same stencil
//
// * Module script case
// the |script| argument must be the script returned by
// |JS::GetModuleScript| called on the module returned by
// |JS::InstantiateModuleStencil| with the same stencil
//
// NOTE: |JS::GetModuleScript| doesn't work after evaluating the
// module script. For the case, use Handle<JSObject*> variant of
// this function below.
//
// The |buffer| argument of |FinishIncrementalEncoding| is used for appending
// the encoded bytecode into the buffer. If any of these functions failed, the
// content of |buffer| would be undefined.
//
// |buffer| contains encoded CompilationStencil.
//
// If the `buffer` isn't empty, the start of the `buffer` should meet
// IsTranscodingBytecodeAligned, and the length should meet
// IsTranscodingBytecodeOffsetAligned.
//
// NOTE: As long as IsTranscodingBytecodeOffsetAligned is met, that means
// there's JS::BytecodeOffsetAlignment+extra bytes in the buffer,
// IsTranscodingBytecodeAligned should be guaranteed to meet by
// malloc, used by MallocAllocPolicy in mozilla::Vector.
extern JS_PUBLIC_API bool FinishIncrementalEncoding(JSContext* cx,
Handle<JSScript*> script,
TranscodeBuffer& buffer);
// Similar to |JS::FinishIncrementalEncoding|, but receives module obect.
//
// The |module| argument must be the module returned by
// |JS::InstantiateModuleStencil| with the same stencil that's passed to
// |JS::StartIncrementalEncoding|.
extern JS_PUBLIC_API bool FinishIncrementalEncoding(JSContext* cx,
Handle<JSObject*> module,
TranscodeBuffer& buffer);
// Instead of transcoding to a buffer, return the JS::Stencil that reflects
// the delazification from the execution.
// The resulting stencil's ownership is passed to the consumer and the
// ref count is 1.
extern JS_PUBLIC_API bool FinishIncrementalEncoding(JSContext* cx,
Handle<JSScript*> script,
JS::Stencil** stencilOut);
// Abort incremental encoding started by JS::StartIncrementalEncoding.
extern JS_PUBLIC_API void AbortIncrementalEncoding(Handle<JSScript*> script);
extern JS_PUBLIC_API void AbortIncrementalEncoding(Handle<JSObject*> module);
// Check if the compile options and script's flag matches.
//
// JS::DecodeScript* and JS::DecodeOffThreadScript internally check this.

46
js/public/experimental/JSStencil.h
View File

@@ -206,22 +206,52 @@ extern JS_PUBLIC_API TranscodeResult
DecodeStencil(JS::FrontendContext* fc, const ReadOnlyDecodeOptions& options,
const TranscodeRange& range, Stencil** stencilOut);
// ************************************************************************
// Collect delazifications
// ************************************************************************
// Start collecting delazifications for given script or module's source object.
//
// If the source object is already collecting delazifications, alreadyStarted is
// set to true and returns true. alreadyStarted is set to false otherwise.
//
// TODO: Rename public APIs.
extern JS_PUBLIC_API bool StartIncrementalEncoding(JSContext* cx,
JS::Handle<JSScript*> script,
Stencil* stencil,
extern JS_PUBLIC_API bool StartCollectingDelazifications(
JSContext* cx, JS::Handle<JSScript*> script, Stencil* stencil,
bool& alreadyStarted);
extern JS_PUBLIC_API bool StartIncrementalEncoding(JSContext* cx,
JS::Handle<JSObject*> module,
Stencil* stencil,
extern JS_PUBLIC_API bool StartCollectingDelazifications(
JSContext* cx, JS::Handle<JSObject*> module, Stencil* stencil,
bool& alreadyStarted);
// Finish collecting delazifications and retrieve the result.
//
// With |buffer| out-parameter, the result is encoded and appended to the
// buffer. If failed, the content of |buffer| would be undefined.
//
// If the `buffer` isn't empty, the start of the `buffer` should meet
// JS::IsTranscodingBytecodeAligned, and the length should meet
// JS::IsTranscodingBytecodeOffsetAligned.
//
// NOTE: As long as IsTranscodingBytecodeOffsetAligned is met, that means
// there's JS::BytecodeOffsetAlignment+extra bytes in the buffer,
// IsTranscodingBytecodeAligned should be guaranteed to meet by
// malloc, used by MallocAllocPolicy in mozilla::Vector.
extern JS_PUBLIC_API bool FinishCollectingDelazifications(
JSContext* cx, Handle<JSScript*> script, TranscodeBuffer& buffer);
// Similar to |JS::FinishCollectingDelazifications|, but receives module obect.
extern JS_PUBLIC_API bool FinishCollectingDelazifications(
JSContext* cx, Handle<JSObject*> module, TranscodeBuffer& buffer);
// Instead of transcoding to a buffer, return the JS::Stencil that reflects
// the delazification from the execution.
extern JS_PUBLIC_API bool FinishCollectingDelazifications(
JSContext* cx, Handle<JSScript*> script, JS::Stencil** stencilOut);
extern JS_PUBLIC_API void AbortCollectingDelazifications(
Handle<JSScript*> script);
extern JS_PUBLIC_API void AbortCollectingDelazifications(
Handle<JSObject*> module);
} // namespace JS
#endif // js_experimental_JSStencil_h

12
js/src/frontend/Stencil.cpp
View File

@@ -5477,20 +5477,20 @@ bool CompilationStencilMerger::addDelazification(
if (destFun.hasSharedData()) {
// If the function was already non-lazy, it means the following happened:
// A. delazified twice within single incremental encoding
// A. delazified twice within single collecting delazifications
// 1. this function is lazily parsed
// 2. incremental encoding is started
// 2. collecting delazifications is started
// 3. this function is delazified, encoded, and merged
// 4. this function is relazified
// 5. this function is delazified, encoded, and merged
//
// B. delazified twice across decode
// 1. this function is lazily parsed
// 2. incremental encoding is started
// 2. collecting delazifications is started
// 3. this function is delazified, encoded, and merged
// 4. incremental encoding is finished
// 4. collecting delazifications is finished
// 5. decoded
// 6. incremental encoding is started
// 6. collecting delazifications is started
// here, this function is non-lazy
// 7. this function is relazified
// 8. this function is delazified, encoded, and merged
@@ -5499,7 +5499,7 @@ bool CompilationStencilMerger::addDelazification(
//
// B cannot happen with public API, but can happen if incremental
// encoding at step B.6 is explicitly started by internal function.
// See Evaluate and StartIncrementalEncoding in js/src/shell/js.cpp.
// See Evaluate and StartCollectingDelazifications in js/src/shell/js.cpp.
return true;
}

9
js/src/shell/js.cpp
View File

@@ -2900,7 +2900,8 @@ static bool Evaluate(JSContext* cx, unsigned argc, Value* vp) {
if (saveIncrementalBytecode) {
bool alreadyStarted;
if (!JS::StartIncrementalEncoding(cx, script, stencil, alreadyStarted)) {
if (!JS::StartCollectingDelazifications(cx, script, stencil,
alreadyStarted)) {
return false;
}
MOZ_ASSERT(!alreadyStarted);
@@ -2931,7 +2932,7 @@ static bool Evaluate(JSContext* cx, unsigned argc, Value* vp) {
// Serialize the encoded bytecode, recorded before the execution, into a
// buffer which can be deserialized linearly.
if (saveIncrementalBytecode) {
if (!FinishIncrementalEncoding(cx, script, saveBuffer)) {
if (!FinishCollectingDelazifications(cx, script, saveBuffer)) {
return false;
}
}
@@ -9719,8 +9720,8 @@ static const JSFunctionSpecWithHelp shell_functions[] = {
" the bytecode would be loaded and decoded from the cache entry instead\n"
" of being parsed, then it would be executed as usual.\n"
" saveIncrementalBytecode: if true, and if the source is a\n"
" CacheEntryObject, the bytecode would be incrementally encoded and\n"
" saved into the cache entry.\n"
" CacheEntryObject, the delazifications are collected during the\n"
" execution, and encoded after that, and saved into the cache entry.\n"
" execute: if false, do not execute the script, but do parse and/or\n"
" transcode.\n"
" assertEqBytecode: if true, and if both loadBytecode and either\n"

47
js/src/vm/CompilationAndEvaluation.cpp
View File

@@ -126,7 +126,8 @@ static bool StartCollectingDelazifications(JSContext* cx,
alreadyStarted = false;
// We don't support asm.js in XDR.
// Failures are reported by the FinishIncrementalEncoding function below.
// Failures are reported by the FinishCollectingDelazifications function
// below.
if (stencil->getInitial()->asmJS) {
return true;
}
@@ -136,24 +137,22 @@ static bool StartCollectingDelazifications(JSContext* cx,
return true;
}
JS_PUBLIC_API bool JS::StartIncrementalEncoding(JSContext* cx,
JS::Handle<JSScript*> script,
JS::Stencil* stencil,
JS_PUBLIC_API bool JS::StartCollectingDelazifications(
JSContext* cx, JS::Handle<JSScript*> script, JS::Stencil* stencil,
bool& alreadyStarted) {
JS::Rooted<ScriptSourceObject*> sso(cx, script->sourceObject());
return StartCollectingDelazifications(cx, sso, stencil, alreadyStarted);
return ::StartCollectingDelazifications(cx, sso, stencil, alreadyStarted);
}
JS_PUBLIC_API bool JS::StartIncrementalEncoding(JSContext* cx,
JS::Handle<JSObject*> module,
JS::Stencil* stencil,
JS_PUBLIC_API bool JS::StartCollectingDelazifications(
JSContext* cx, JS::Handle<JSObject*> module, JS::Stencil* stencil,
bool& alreadyStarted) {
JS::Rooted<ScriptSourceObject*> sso(
cx, module->as<ModuleObject>().scriptSourceObject());
return StartCollectingDelazifications(cx, sso, stencil, alreadyStarted);
return ::StartCollectingDelazifications(cx, sso, stencil, alreadyStarted);
}
static bool FinishIncrementalEncoding(JSContext* cx,
static bool FinishCollectingDelazifications(JSContext* cx,
JS::Handle<ScriptSourceObject*> sso,
JS::TranscodeBuffer& buffer) {
RefPtr<frontend::InitialStencilAndDelazifications> stencils =
@@ -189,7 +188,7 @@ static bool FinishIncrementalEncoding(JSContext* cx,
return true;
}
static bool FinishIncrementalEncoding(JSContext* cx,
static bool FinishCollectingDelazifications(JSContext* cx,
JS::Handle<ScriptSourceObject*> sso,
JS::Stencil** stencilOut) {
RefPtr<frontend::InitialStencilAndDelazifications> stencils =
@@ -203,36 +202,34 @@ static bool FinishIncrementalEncoding(JSContext* cx,
return true;
}
JS_PUBLIC_API bool JS::FinishIncrementalEncoding(JSContext* cx,
JS::HandleScript script,
JS::TranscodeBuffer& buffer) {
JS_PUBLIC_API bool JS::FinishCollectingDelazifications(
JSContext* cx, JS::HandleScript script, JS::TranscodeBuffer& buffer) {
JS::Rooted<ScriptSourceObject*> sso(cx, script->sourceObject());
return ::FinishIncrementalEncoding(cx, sso, buffer);
return ::FinishCollectingDelazifications(cx, sso, buffer);
}
JS_PUBLIC_API bool JS::FinishIncrementalEncoding(JSContext* cx,
JS::HandleScript script,
JS::Stencil** stencilOut) {
JS_PUBLIC_API bool JS::FinishCollectingDelazifications(
JSContext* cx, JS::HandleScript script, JS::Stencil** stencilOut) {
JS::Rooted<ScriptSourceObject*> sso(cx, script->sourceObject());
return ::FinishIncrementalEncoding(cx, sso, stencilOut);
return ::FinishCollectingDelazifications(cx, sso, stencilOut);
}
JS_PUBLIC_API bool JS::FinishIncrementalEncoding(JSContext* cx,
JS::Handle<JSObject*> module,
JS::TranscodeBuffer& buffer) {
JS_PUBLIC_API bool JS::FinishCollectingDelazifications(
JSContext* cx, JS::Handle<JSObject*> module, JS::TranscodeBuffer& buffer) {
JS::Rooted<ScriptSourceObject*> sso(
cx, module->as<ModuleObject>().scriptSourceObject());
return ::FinishIncrementalEncoding(cx, sso, buffer);
return ::FinishCollectingDelazifications(cx, sso, buffer);
}
JS_PUBLIC_API void JS::AbortIncrementalEncoding(JS::HandleScript script) {
JS_PUBLIC_API void JS::AbortCollectingDelazifications(JS::HandleScript script) {
if (!script) {
return;
}
script->sourceObject()->clearStencils();
}
JS_PUBLIC_API void JS::AbortIncrementalEncoding(JS::Handle<JSObject*> module) {
JS_PUBLIC_API void JS::AbortCollectingDelazifications(
JS::Handle<JSObject*> module) {
module->as<ModuleObject>().scriptSourceObject()->clearStencils();
}