diff --git a/Source/JavaScriptCore/aot/codegen/AOTCodeGenerator.cpp b/Source/JavaScriptCore/aot/codegen/AOTCodeGenerator.cpp index 01289eead18d0..a80966b6d04da 100644 --- a/Source/JavaScriptCore/aot/codegen/AOTCodeGenerator.cpp +++ b/Source/JavaScriptCore/aot/codegen/AOTCodeGenerator.cpp @@ -3304,6 +3304,7 @@ NEVER_INLINE void CodeGenerator::endScheduledLifetimes(const ValueContext& conte NEVER_INLINE void CodeGenerator::generateWatched(const ValueContext& context) { const OperationContext* user = std::exchange(m_operation, &context); + const bool userDeclaresAccesses = user && m_out.hasDeclaredAccesses(); Machine::Origin originOfUser = m_out.origin(); m_out.setOrigin(machineOriginOf(context.id())); bool userOwesFenceBehindStores = std::exchange(m_owesFenceBehindStores, false); @@ -3323,7 +3324,7 @@ NEVER_INLINE void CodeGenerator::generateWatched(const ValueContext& context) if (m_looksBehindEachOperation) [[unlikely]] { if (barrierIsCountedOn(context.id()) && !m_storesBehindWhichOwnerIsRemembered.get(context.id().index()) && !m_hasFailed) fail(context, InternalErrorKind::OpcodeNotInForm, "the barrier of an earlier store is left to this one, and the code of this one does not remember its owner"_s); - if (m_checksAllocation && user) + if (m_checksAllocation && userDeclaresAccesses) declareAccessesSlow(*user); else if (m_checksAllocation) m_out.clearDeclaredAccesses(); diff --git a/Source/JavaScriptCore/aot/machine/AOTMachineBuilder.h b/Source/JavaScriptCore/aot/machine/AOTMachineBuilder.h index 1e885a543ea50..6d1902182aa74 100644 --- a/Source/JavaScriptCore/aot/machine/AOTMachineBuilder.h +++ b/Source/JavaScriptCore/aot/machine/AOTMachineBuilder.h @@ -173,6 +173,7 @@ class Builder { JS_EXPORT_PRIVATE void setDeclaredAccesses(const HeapSet& reads, const HeapSet& writes); JS_EXPORT_PRIVATE void clearDeclaredAccesses(); + bool hasDeclaredAccesses() const { return m_suspensionsOfDeclaredAccesses ? m_hadDeclaredAccessesWhenSuspended : m_hasDeclaredAccesses; } void suspendDeclaredAccesses() { if (!m_suspensionsOfDeclaredAccesses++) { diff --git a/Source/JavaScriptCore/aot/runtime/AOTModuleEvaluation.cpp b/Source/JavaScriptCore/aot/runtime/AOTModuleEvaluation.cpp index 7ef60a712399d..3368dba92b411 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModuleEvaluation.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTModuleEvaluation.cpp @@ -5285,7 +5285,7 @@ JSValue Modules::answerRequire(ModuleID target, ModuleID referrer, RequiredBy re tellOfFilesThatStayedLoadedBelow(target); if (m_modulesReleasedByLoader.get(target.index()) && !hasInstances(target)) [[unlikely]] bringBackWhatLoaderLetGoBelow(target); - if (isEvaluatedUnderPendingPatch(target)) [[unlikely]] + if (isEvaluatedUnderPendingPatch(target, referrer)) [[unlikely]] tellThatFileDidNotRunAgain(fileOf(target)); if (!m_modulesWithRunningFactory.isEmpty()) [[unlikely]] tellIfFactoryIsRunning(target, LoadKind::Require); diff --git a/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h b/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h index 25e2e27efba9e..8331c653ae3d0 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModuleHost.h @@ -329,6 +329,7 @@ JS_EXPORT_PRIVATE bool wasDisplacedDuringEvaluation(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool wasRegisteredByFailedLoad(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool wasLinkedBeforeTestFile(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool wasLinkedByFailedGraph(JSGlobalObject*, ModuleID, bool byEarlierTestFile = false); +JS_EXPORT_PRIVATE bool failedWithImportInEarlierTestFile(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool wasLinkedBeforeLinkFailure(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool hasImporterLinkedBeforeFailure(JSGlobalObject*, ModuleID); JS_EXPORT_PRIVATE bool isLinkedForPendingImporter(JSGlobalObject*, ModuleID, std::optional asking); @@ -441,6 +442,7 @@ JS_EXPORT_PRIVATE bool fulfillDeferredFetches(VM&, uint64_t completedDiskReads = JS_EXPORT_PRIVATE void didDrainDeferredFetchJobs(VM&); JS_EXPORT_PRIVATE std::optional firstDeferredBatchNumber(VM&); JS_EXPORT_PRIVATE bool shouldDeferFetchFulfillment(JSGlobalObject*, ModuleID); +JS_EXPORT_PRIVATE bool isImportedByLoad(JSGlobalObject*, ModuleID root, ModuleID file); JS_EXPORT_PRIVATE void deferFetchFulfillment(JSGlobalObject*, ModuleID, JSPromise* fetched, AbstractModuleRecord*); JS_EXPORT_PRIVATE void didFetch(JSGlobalObject*, AbstractModuleRecord*); JS_EXPORT_PRIVATE void noteHostImportInFlight(JSGlobalObject*, ModuleID, JSPromise*, bool isFromOwnFactory); diff --git a/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp b/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp index 55cc6882bb0e4..7d306887dd3fa 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTModuleInstances.cpp @@ -3469,14 +3469,15 @@ void Modules::reportImportersWithoutInstances(ModuleID module) } } -bool Modules::isEvaluatedUnderPendingPatch(ModuleID module) +bool Modules::isEvaluatedUnderPendingPatch(ModuleID module, ModuleID requirer) { ModuleID file = fileOf(module); if (!host().isPatchPending || status(file) != ModuleStatus::Evaluated || !m_table.hasFilePath(file)) [[likely]] return false; if (!isPatchPending(file)) [[likely]] return false; - if (activeMock(file) || hasIntactOriginal(file) || isPatchedByMock(file) || m_originalsEvaluatedUnderMock.get(file.index()) || hasRunBesideMockAlone(file)) + bool isPatchedForRequirer = isPatchedByMock(file) && !(requirer && data(requirer).isEntryPoint()); + if (activeMock(file) || hasIntactOriginal(file) || isPatchedForRequirer || m_originalsEvaluatedUnderMock.get(file.index()) || hasRunBesideMockAlone(file)) return false; return data(file).kind == ModuleKind::CommonJs ? wasLoadedByImport(file) : !!currentInstance(file); } diff --git a/Source/JavaScriptCore/aot/runtime/AOTModuleRecord.h b/Source/JavaScriptCore/aot/runtime/AOTModuleRecord.h index 8c4a5fe4a8c6c..969341f0b5261 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModuleRecord.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModuleRecord.h @@ -10,6 +10,7 @@ #include "AOTRecordTypes.h" #include "AOTVector.h" #include "CyclicModuleRecord.h" +#include "VM.h" #include #include #include @@ -224,6 +225,12 @@ class ModuleRecord final : public CyclicModuleRecord { WriteBarrier m_moduleInstance; }; +template +ALWAYS_INLINE ModuleRecord* compiledModule(const VM& vm, T module) +{ + return vm.hasCompiledCode() ? dynamicDowncast(module) : nullptr; +} + void tryBindOriginal(JSGlobalObject*, JSModuleRecord*); void noteOriginalsRequestedBySource(JSGlobalObject*, JSModuleRecord* importer); void linkOriginal(JSGlobalObject*, JSModuleRecord*); diff --git a/Source/JavaScriptCore/aot/runtime/AOTModules.cpp b/Source/JavaScriptCore/aot/runtime/AOTModules.cpp index d10706c2dbe17..cbe9b16ac9764 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModules.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTModules.cpp @@ -5602,6 +5602,10 @@ JSPromise* Modules::startImport(ModuleID module, std::optional referrer factories = pendingFactoryInGraph(module, askedBy, importWaitState); RETURN_IF_EXCEPTION(scope, rejectedPromiseWithPendingException(realm, scope)); } + if (!factories && text != ImportSourceState::MayArriveLater && askedBy == PendingFactoryRequester::ImportCall) [[unlikely]] { + factories = pendingFactoryInGraph(module, PendingFactoryRequester::ImportCallAfterSource, importWaitState); + RETURN_IF_EXCEPTION(scope, rejectedPromiseWithPendingException(realm, scope)); + } if (!factories && needsOriginal) [[unlikely]] { factories = ensureActualKeyLoad(fileOf(module)); RETURN_IF_EXCEPTION(scope, rejectedPromiseWithPendingException(realm, scope)); @@ -9340,6 +9344,12 @@ bool wasLinkedByFailedGraph(JSGlobalObject* realm, ModuleID module, bool byEarli return modules && modules->wasLinkedByFailedGraph(module, byEarlierTestFile); } +bool failedWithImportInEarlierTestFile(JSGlobalObject* realm, ModuleID module) +{ + Modules* modules = modulesOf(realm); + return modules && modules->failedWithImportInEarlierTestFile(module); +} + bool hasImporterLinkedBeforeFailure(JSGlobalObject* realm, ModuleID module) { Modules* modules = modulesOf(realm); diff --git a/Source/JavaScriptCore/aot/runtime/AOTModules.h b/Source/JavaScriptCore/aot/runtime/AOTModules.h index 57046b176a8e4..935c075053bcb 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTModules.h +++ b/Source/JavaScriptCore/aot/runtime/AOTModules.h @@ -919,6 +919,7 @@ class Modules { void forgetLoadsRefusedByCheckOfNames(ModuleID mocked); bool wasRegisteredByFailedLoad(ModuleID) const; bool wasLinkedByFailedGraph(ModuleID, bool byEarlierTestFile); + bool failedWithImportInEarlierTestFile(ModuleID); bool isImportedByFailedRoot(ModuleID, bool ofEarlierTestFile = false) const; bool wasReachedByFailedGraph(ModuleID) const; bool isFailedLoadRoot(ModuleID module) const { return m_loadRoots.get(module.index()) && status(module) == ModuleStatus::Failed; } @@ -1491,7 +1492,7 @@ class Modules { bool isRequiredModulePatchPending(ModuleID); std::optional importOriginalUnderPatch(ModuleID, ModuleID referrer, const RefPtr&); bool isPatchPending(ModuleID file) const; - bool isEvaluatedUnderPendingPatch(ModuleID); + bool isEvaluatedUnderPendingPatch(ModuleID, ModuleID requirer); void tellIfFactoryIsRunning(ModuleID requested, LoadKind); void tellIfPatchIsPending(ModuleID required); bool isRequireUnderPendingMock(ModuleID required, ModuleID requirer); @@ -1928,6 +1929,7 @@ class Modules { void fulfillQueuedFetch(JSPromise*); void fulfillQueuedFetchAfterJobs(JSPromise*); bool isOriginalLoaded(ModuleID); + bool isImportedByLoad(ModuleID root, ModuleID file) const; enum class AskedBy : bool { Loader, Import }; bool textOfImportComesInLaterTurn(ModuleID, AskedBy); bool hasTextAtHand() const; diff --git a/Source/JavaScriptCore/aot/runtime/AOTPropertyCachesAnswers.cpp b/Source/JavaScriptCore/aot/runtime/AOTPropertyCachesAnswers.cpp index 22960ff518a6e..e150e12b7c970 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTPropertyCachesAnswers.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTPropertyCachesAnswers.cpp @@ -73,6 +73,8 @@ static bool isFunctionOwnName(VM& vm, UniquedStringImpl* uid) bool isNeverCachedName(VM& vm, UniquedStringImpl* uid) { + if (uid->length() == 10 && equal(uid, "4294967295"_s)) [[unlikely]] + return true; return parseIndex(PropertyName(uid)) || uid == vm.propertyNames->underscoreProto.impl() || (PropertyName(uid).isPrivateName() && !PropertyName(uid).passesThroughProxies()); } diff --git a/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp b/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp index d083a7f9d3b84..7f5d4d4f6b713 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTTestRunFactories.cpp @@ -326,6 +326,17 @@ bool Modules::wasLinkedByFailedGraph(ModuleID module, bool byEarlierTestFile) return data(module).isESModuleOfProgram() && !data(module).isFacade() && status(module) <= ModuleStatus::Linked && !hasRun(module) && !didCaptureExports(module) && (!byEarlierTestFile || !wasLoadedByTestFile(module)) && isImportedByFailedRoot(module, byEarlierTestFile); } +bool Modules::failedWithImportInEarlierTestFile(ModuleID module) +{ + if (!isFailedESModule(module) || isMocked(module) || activeMock(module) || m_loadedInPreload.get(module.index()) || wasLoadedByTestFile(module)) + return false; + for (size_t index : staticImportClosure(module, MockTraversal::Continue)) { + if (ModuleID imported(index); imported != module && isFailedESModule(imported) && !isMocked(imported)) + return true; + } + return false; +} + bool Modules::wasReachedByFailedGraph(ModuleID module) const { for (uint32_t index = 0; index < m_table.size(); ++index) { @@ -1347,9 +1358,14 @@ bool Modules::runMocksInFetchedGraphSlow(ModuleID module) return false; evaluateModulesOwedBelow(module); RETURN_IF_EXCEPTION(scope, false); - scope.release(); - if (m_modulesWithPendingMock.isEmpty()) [[likely]] + auto noteRequest = [&] { + if (data(module).isESModuleOfProgram() && wasActiveMockEntryRemoved(module)) + noteImportUnderMockInPlace(module); + }; + if (m_modulesWithPendingMock.isEmpty()) [[likely]] { + noteRequest(); return false; + } bool isAskedForByImportCall = m_instance.vm->aotState().importFrameInLoader; if (isAskedForByImportCall) clearCachedMockError(module); @@ -1357,7 +1373,11 @@ bool Modules::runMocksInFetchedGraphSlow(ModuleID module) SetForScope moduleBeingFetched(m_moduleBeingFetched, loadOfFetch(module)); bool wasFetchedForStatement = m_statementFetchesDelayedByTick.get(module.index()); m_statementFetchesDelayedByTick.clear(module.index()); - return runMocksInGraph(module, wasFetchedForStatement || (!isAskedForByImportCall && isFetchedForImportStatement(module)) ? LoadRootKind::ImportStatement : LoadRootKind::StartsLoad); + bool hasCalledWaitingFactory = runMocksInGraph(module, wasFetchedForStatement || (!isAskedForByImportCall && isFetchedForImportStatement(module)) ? LoadRootKind::ImportStatement : LoadRootKind::StartsLoad); + RETURN_IF_EXCEPTION(scope, false); + if (!hasCalledWaitingFactory) + noteRequest(); + return hasCalledWaitingFactory; } void Modules::willFetchAfterTick(ModuleID module) diff --git a/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp b/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp index 0dcbb16815d56..549e7e6a6c5f5 100644 --- a/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp +++ b/Source/JavaScriptCore/aot/runtime/AOTTestRunImportTurns.cpp @@ -82,6 +82,20 @@ bool Modules::isFetchedBesideFactory(ModuleID module) return false; } +bool Modules::isImportedByLoad(ModuleID root, ModuleID file) const +{ + for (size_t index : modulesInLoadGraph(root)) { + ModuleID importer(index); + if (isCommonJSModuleOrFacade(importer) || status(importer) >= ModuleStatus::Evaluating) + continue; + for (const ModuleRequestData& request : m_table.imports(importer)) { + if (fileOf(moduleLoadedBy(request)) == file) + return true; + } + } + return false; +} + bool Modules::textOfImportComesInLaterTurn(ModuleID module, AskedBy askedBy) { ModuleID file = fileOf(module); @@ -923,6 +937,12 @@ bool wasOriginalRequiredFirst(JSGlobalObject* realm, ModuleID file) return modules && modules->wasOriginalRequiredFirst(file); } +bool isImportedByLoad(JSGlobalObject* realm, ModuleID root, ModuleID file) +{ + Modules* modules = modulesOf(realm); + return modules && modules->isImportedByLoad(root, file); +} + bool isMockUnseen(JSGlobalObject* realm, ModuleID mocked) { Modules* modules = modulesOf(realm); diff --git a/Source/JavaScriptCore/aot/walk/AOTCodeVerifier.cpp b/Source/JavaScriptCore/aot/walk/AOTCodeVerifier.cpp index 446b4b631ff62..913470fa625d1 100644 --- a/Source/JavaScriptCore/aot/walk/AOTCodeVerifier.cpp +++ b/Source/JavaScriptCore/aot/walk/AOTCodeVerifier.cpp @@ -154,6 +154,7 @@ class CodeVerifier { void verifyUsersOfReadNumbers(); bool treatsUndefinedAsNaN(ValueID, const Operation& user, uint32_t operandIndex) const; bool isOperatorSpecializationCheck(ValueID test) const; + bool failingEdgeLeavesScope(ValueID test) const; void verifyTestsPassed(); void verifyLengthsHeldAgainst(); void verifyDataViewAccesses(); @@ -1487,6 +1488,10 @@ bool CodeVerifier::isOperatorSpecializationCheck(ValueID test) const BitVector names(m_code.numberOfValues()); bool isUsedOnPass = false; bool isUsedOnFailure = false; + bool isUsedByOtherOperator = false; + const bool isAtInlinedCall = std::ranges::any_of(m_code.inlineFrames().subspan(1), [&](const InlineFrame& copied) { + return copied.parent == asked.inlineFrame && copied.callPosition == asked.position; + }); for (bool someNameIsNew = true; std::exchange(someNameIsNew, false);) { for (BlockID block : m_reachedBlocks) { for (ValueID id : operationsOf(block)) { @@ -1502,32 +1507,52 @@ bool CodeVerifier::isOperatorSpecializationCheck(ValueID test) const name = m_code.at(name).operand(0); return m_code.at(name).isOnTakenEdge(); }; - BitVector isBehindFailingEdge(m_code.numberOfBlocks()); - const BlockID blockOfTest = m_code.blockOf(test); - if (EdgeID fails = findAnswerEdge(test, false, blockOfTest)) { - Vector waiting { m_code.at(fails).to }; - while (!waiting.isEmpty()) { - BlockID block = waiting.takeLast(); - if (!isReached(block) || dominates(headOf(block), headOf(blockOfTest)) || isBehindFailingEdge.set(block.index())) - continue; - m_code.forEachEdgeOf(block, [&](EdgeID, const Edge& edge) { - waiting.append(edge.to); - }); + auto arrivesIn = [](const BitVector& found, ValueID value) { return value && found.get(value.index()); }; + auto followThroughParameters = [&](BitVector& found, const auto& isFirst) { + for (bool someArrivesFurther = true; std::exchange(someArrivesFurther, false);) { + for (BlockID block : m_reachedBlocks) { + for (ValueID id : operationsOf(block)) { + const Operation& record = m_code.at(id); + if (valuePreservingOpcodes.contains(record.opcode) && !names.get(id.index()) && arrivesIn(found, record.operand(0)) && !found.set(id.index())) + someArrivesFurther = true; + } + m_code.forEachEdgeOf(block, [&](EdgeID, const Edge& edge) { + std::span parameters = m_code.at(edge.to).parameters(); + std::span arguments = edge.arguments(); + for (size_t place = 0; place < std::min(arguments.size(), parameters.size()); ++place) { + if (arguments[place] && (arrivesIn(found, arguments[place]) || isFirst(arguments[place])) && !found.set(parameters[place].index())) + someArrivesFurther = true; + } + }); + } } - } + }; + BitVector arrivals(m_code.numberOfValues()); + followThroughParameters(arrivals, [&](ValueID argument) { return names.get(argument.index()) && isOnPassingEdge(argument); }); + BitVector arrivalsOfValue(m_code.numberOfValues()); + arrivalsOfValue.set(asked.valueOperand().index()); + followThroughParameters(arrivalsOfValue, [&](ValueID argument) { return names.get(argument.index()) && !isOnPassingEdge(argument); }); for (BlockID block : m_reachedBlocks) { for (ValueID id : operationsOf(block)) { const Operation& user = m_code.at(id); for (uint32_t operandIndex = 0; operandIndex < user.numberOfOperands(); ++operandIndex) { + const bool isOperator = (allRelations | arithmeticOnTwoNumbersInCodeVerifier).contains(user.opcode) && user.position == asked.position && user.inlineFrame == asked.inlineFrame; + isUsedOnPass |= isOperator && arrivesIn(arrivals, user.operand(operandIndex)); + isUsedOnFailure |= isOperator && arrivesIn(arrivalsOfValue, user.operand(operandIndex)); if (user.operand(operandIndex) == test && (user.opcode != Opcode::Narrowed || user.valueOperand() == test)) return false; - if (user.operand(operandIndex) == asked.valueOperand() && (allRelations | arithmeticOnTwoNumbersInCodeVerifier).contains(user.opcode) && user.position == asked.position && user.inlineFrame == asked.inlineFrame && isBehindFailingEdge.get(block.index())) + if (user.operand(operandIndex) == asked.valueOperand() && (allRelations | arithmeticOnTwoNumbersInCodeVerifier).contains(user.opcode) && user.position == asked.position && user.inlineFrame == asked.inlineFrame) isUsedOnFailure = true; if (!user.operand(operandIndex) || !names.get(user.operand(operandIndex).index()) || names.get(id.index())) continue; - if (user.position != asked.position || user.inlineFrame != asked.inlineFrame) - return false; - (isOnPassingEdge(user.operand(operandIndex)) ? isUsedOnPass : isUsedOnFailure) = true; + bool isOnPass = isOnPassingEdge(user.operand(operandIndex)); + if (user.position != asked.position || user.inlineFrame != asked.inlineFrame) { + bool isArithmetic = user.opcode != Opcode::TypeTest && treatsUndefinedAsNaN(id, user, operandIndex); + if (!isArithmetic || !isOnPass || !isAtInlinedCall) + return false; + isUsedByOtherOperator = true; + } + (isOnPass ? isUsedOnPass : isUsedOnFailure) = true; } } const Terminator& end = m_code.at(block).terminator; @@ -1542,7 +1567,27 @@ bool CodeVerifier::isOperatorSpecializationCheck(ValueID test) const if (isEdgeArgument) return false; } - return isUsedOnPass && isUsedOnFailure; + return isUsedOnPass && ((isUsedOnFailure && !isUsedByOtherOperator) || failingEdgeLeavesScope(test)); +} + +bool CodeVerifier::failingEdgeLeavesScope(ValueID test) const +{ + ValueID value = m_code.at(test).valueOperand(); + bool leavesScope = false; + for (BlockID block : m_reachedBlocks) { + EdgeID edge = findAnswerEdge(test, false, block); + if (!edge) + continue; + BlockID to = m_code.at(edge).to; + for (uint32_t step = 0; isDefinedWhereBlockMayThrow(value, to); ++step) { + const Terminator& end = m_code.at(to).terminator; + if (step == m_code.numberOfBlocks() || end.kind != TerminatorKind::Jump || !std::ranges::all_of(operationsOf(to), [&](ValueID id) { return m_code.at(id).traits().isPure(); })) + return false; + to = m_code.at(end.next()).to; + } + leavesScope = true; + } + return leavesScope; } bool CodeVerifier::treatsUndefinedAsNaN(ValueID id, const Operation& user, uint32_t operandIndex) const diff --git a/Source/JavaScriptCore/aot/walk/AOTWalkIteration.cpp b/Source/JavaScriptCore/aot/walk/AOTWalkIteration.cpp index b0b5936035d85..25802716ed60f 100644 --- a/Source/JavaScriptCore/aot/walk/AOTWalkIteration.cpp +++ b/Source/JavaScriptCore/aot/walk/AOTWalkIteration.cpp @@ -681,23 +681,50 @@ static uint32_t endOfRowOfAppendsInIteration(const BodyIndex& index, const BodyB static FunctionID functionWrittenUnderNextOfIteratorOf(Walker&, ValueID iterated); -static bool returnsFreshIterator(const Walker& walker, FunctionID function) +static ValueID callHandedBack(const Walker& walker, FunctionID function) { const BodyIndex* body = walker.facts().bodies().find(function); if (!body || walker.program().at(function).isCoroutine()) - return false; + return { }; ValueID returned; for (uint32_t number = 0; number < body->numberOfBlocks(); ++number) { BodyTerminator end = body->terminator(BlockID(number)); if (!body->isReachable(BlockID(number)) || (end.kind() != TerminatorKind::Return && end.kind() != TerminatorKind::ReturnCall)) continue; if (returned || !end.operand(0)) - return false; + return { }; returned = end.operand(0); while (!body->isParameter(returned) && inputPassThroughOpcodes.contains(body->opcodeOf(returned)) && body->useCount(returned) == 1) returned = body->value(returned).operand(0); } - return returned && !body->isParameter(returned) && body->opcodeOf(returned) == Opcode::Call && body->useCount(returned) == 1 && body->value(returned).as().argumentsOperands().empty(); + bool isFresh = returned && !body->isParameter(returned) && body->opcodeOf(returned) == Opcode::Call && body->useCount(returned) == 1 && body->value(returned).as().argumentsOperands().empty(); + return isFresh ? returned : ValueID(); +} + +static bool returnsFreshIterator(const Walker& walker, FunctionID function) +{ + return !!callHandedBack(walker, function); +} + +static bool isHandedBackUntouched(const Walker& walker, Reference value, uint32_t firstFrame) +{ + const auto& frames = walker.code().inlineFrames(); + const Operation& made = walker.code().at(underlyingCellOf(walker.code(), value.id())); + if (made.inlineFrame < firstFrame) + return false; + uint32_t position = made.position; + for (uint32_t frame = made.inlineFrame; frame != walker.inlineFrameAtWork(); frame = frames[frame].parent) { + if (!frame || !frames[frame].callee) + return false; + if (!frames[frame].calledBuiltin) { + const FunctionID function(frames[frame].callee); + ValueID call = callHandedBack(walker, function); + if (!call || walker.facts().bodies().find(function)->value(call).origin().position != position) + return false; + } + position = frames[frame].callPosition; + } + return true; } static std::optional findCollectionOfIterator(Walker& walker, Reference iterator, Reference& collection) @@ -1315,12 +1342,13 @@ class BuilderOfIteration { return m_walker.isUnreachable() ? std::optional(Walker::IndexedIteration()) : std::nullopt; m_walker.count(StatisticID::IteratorMethodsCalledDirectly); + const uint32_t firstFrameOfCall = static_cast(m_walker.code().inlineFrames().size()); Reference iterator = call(method, iterable); if (m_walker.isUnreachable()) return Walker::IndexedIteration(); Reference collection; std::optional stepped = findCollectionOfIterator(m_walker, iterator, collection); - if (!stepped) + if (!stepped || !isHandedBackUntouched(m_walker, iterator, firstFrameOfCall)) return openByProtocolAlone(iterable, iterator); m_walker.count(StatisticID::IteratorAllocationsElidedInInlinees); if (stepped->contents == ContentsStepped::List) { diff --git a/Source/JavaScriptCore/aot/walk/AOTWalkLoopsBuiltTwice.cpp b/Source/JavaScriptCore/aot/walk/AOTWalkLoopsBuiltTwice.cpp index 4ebbf706be716..4e7306540b127 100644 --- a/Source/JavaScriptCore/aot/walk/AOTWalkLoopsBuiltTwice.cpp +++ b/Source/JavaScriptCore/aot/walk/AOTWalkLoopsBuiltTwice.cpp @@ -2611,6 +2611,13 @@ bool Walker::tryBranchInPreheader(Reference test, bool passesWithYes, IterationP BlockID behind = earlier + 1 < loop.earlierPreheaderBlocks.size() ? loop.earlierPreheaderBlocks[earlier + 1] : front; if (behind != front && !testsWithoutNarrowedValue.contains(m_code.at(test.id()).opcode)) continue; + if (behind == front && checksProofs() && !testsWithoutNarrowedValue.contains(m_code.at(test.id()).opcode)) { + bool holdsMore = false; + for (ValueID id = m_code.lastOperationOf(front); id && !holdsMore; id = m_code.at(id).previous) + holdsMore = m_code.at(id).opcode != Opcode::Narrowed && !operationsThatStandAmongNarrowedValues.contains(m_code.at(id).opcode); + if (holdsMore) + continue; + } if (m_code.at(passesWithYes ? end.taken() : end.notTaken()).to == behind) { count(StatisticID::PreheaderChecksEliminated); return true; diff --git a/Source/JavaScriptCore/runtime/AbstractModuleRecord.cpp b/Source/JavaScriptCore/runtime/AbstractModuleRecord.cpp index 019e4ded7e983..4f6fad54ffafb 100644 --- a/Source/JavaScriptCore/runtime/AbstractModuleRecord.cpp +++ b/Source/JavaScriptCore/runtime/AbstractModuleRecord.cpp @@ -1354,7 +1354,7 @@ auto AbstractModuleRecord::resolveExportImpl(JSGlobalObject* globalObject, const frames[0] = firstLiveRecordViaStarExport; #endif #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(root.moduleRecord); compiled && frames[0].type == Resolution::Type::Resolved) { + if (auto* compiled = AOT::compiledModule(vm, root.moduleRecord); compiled && frames[0].type == Resolution::Type::Resolved) { if (compiled->hasAnyActiveMock() || compiled->mayOutlive(frames[0].moduleRecord) || frames[0].moduleRecord->hasLiveExports() || wasAmbiguityResolvedByMock || wasResolvedByRemovedMock) { if (!wasAmbiguityResolvedByMock && !wasResolvedByRemovedMock) compiled->storeResolution(root.exportName.get(), frames[0]); @@ -1416,7 +1416,7 @@ auto AbstractModuleRecord::resolveExportByName(JSGlobalObject* globalObject, con #endif #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) { + if (auto* compiled = AOT::compiledModule(vm, this)) { if (!compiled->hasAnyActiveMock()) { if (std::optional cachedResolution = tryGetCachedResolution(exportName.impl())) return *cachedResolution; @@ -1456,7 +1456,7 @@ auto AbstractModuleRecord::resolveExportByName(JSGlobalObject* globalObject, con JSObject* AbstractModuleRecord::moduleNamespaceObject(JSGlobalObject* globalObject, ModulePhase phase) { #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) + if (auto* compiled = AOT::compiledModule(globalObject->vm(), this)) return compiled->moduleNamespaceObject(globalObject, phase); #endif return getModuleNamespace(globalObject, phase); @@ -1464,10 +1464,10 @@ JSObject* AbstractModuleRecord::moduleNamespaceObject(JSGlobalObject* globalObje JSModuleNamespaceObject* AbstractModuleRecord::getModuleNamespace(JSGlobalObject* globalObject, ModulePhase phase, bool shouldPreventExtensions) { + VM& vm = globalObject->vm(); #if ENABLE(AOT) - RELEASE_ASSERT(!inherits()); + RELEASE_ASSERT(!AOT::compiledModule(vm, this)); #endif - VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); #if ASSERT_ENABLED @@ -1526,7 +1526,7 @@ JSModuleNamespaceObject* AbstractModuleRecord::getModuleNamespace(JSGlobalObject #endif #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(moduleRecord)) { + if (auto* compiled = AOT::compiledModule(vm, moduleRecord)) { Vector names; compiled->collectExportedNames(globalObject, names, pendingModules); RETURN_IF_EXCEPTION(scope, nullptr); @@ -1886,7 +1886,7 @@ void AbstractModuleRecord::link(JSGlobalObject* globalObject, RefPtr(this)) { + if (auto* compiled = AOT::compiledModule(vm, this)) { compiled->adoptStatusIfNeeded(); // A linked module stays linked no matter how this step ends. The loader is done with the graph. if (compiled->status() >= CyclicModuleRecord::Status::Linked) { @@ -1951,7 +1951,7 @@ JSPromise* AbstractModuleRecord::evaluate(JSGlobalObject* globalObject) }; #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) { + if (auto* compiled = AOT::compiledModule(vm, this)) { compiled->adoptStatusIfNeeded(); // An importer of a CommonJS module that is still evaluating gets whatever the module has exported so far. if (compiled->isEvaluatingCommonJSModule()) @@ -2162,7 +2162,7 @@ unsigned AbstractModuleRecord::innerModuleEvaluation(JSGlobalObject* globalObjec VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) + if (auto* compiled = AOT::compiledModule(vm, this)) RELEASE_AND_RETURN(scope, compiled->innerModuleEvaluation(globalObject, stack, index, referrerAsyncOrder, dynamicImportPromise)); #endif auto* module = dynamicDowncast(this); @@ -2365,7 +2365,7 @@ void AbstractModuleRecord::generateDeferredSyntheticModules(JSGlobalObject* glob if (auto* synthetic = dynamicDowncast(this)) RELEASE_AND_RETURN(scope, synthetic->runDeferredGenerator(globalObject)); #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) + if (auto* compiled = AOT::compiledModule(vm, this)) RELEASE_AND_RETURN(scope, compiled->generateDeferredSyntheticModules(globalObject, visited)); #endif @@ -2397,7 +2397,7 @@ unsigned AbstractModuleRecord::innerModuleLinking(JSGlobalObject* globalObject, VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) + if (auto* compiled = AOT::compiledModule(vm, this)) RELEASE_AND_RETURN(scope, compiled->innerModuleLinking(globalObject, stack, index, WTF::move(scriptFetcher))); #endif auto* module = dynamicDowncast(this); diff --git a/Source/JavaScriptCore/runtime/CommonSlowPathsInlines.h b/Source/JavaScriptCore/runtime/CommonSlowPathsInlines.h index b72774bcc2afa..6477bc3bf69e6 100644 --- a/Source/JavaScriptCore/runtime/CommonSlowPathsInlines.h +++ b/Source/JavaScriptCore/runtime/CommonSlowPathsInlines.h @@ -84,7 +84,10 @@ inline void tryCachePutToScopeGlobal( case GlobalPropertyWithVarInjectionChecks: { // Global Lexical Binding Epoch is changed. Update op_get_from_scope from GlobalProperty to GlobalLexicalVar. if (scope->isGlobalLexicalEnvironment()) { - cacheGlobalLexicalVar(codeBlock, metadata, uncheckedDowncast(scope), ident); + auto* globalLexicalEnvironment = uncheckedDowncast(scope); + if (getVM(globalObject).hasCompiledCode() && globalLexicalEnvironment->symbolTable()->get(ident.impl()).isReadOnly()) + return; + cacheGlobalLexicalVar(codeBlock, metadata, globalLexicalEnvironment, ident); return; } break; diff --git a/Source/JavaScriptCore/runtime/CyclicModuleRecord.cpp b/Source/JavaScriptCore/runtime/CyclicModuleRecord.cpp index 254ce64d7bd55..c738bf4e00b52 100644 --- a/Source/JavaScriptCore/runtime/CyclicModuleRecord.cpp +++ b/Source/JavaScriptCore/runtime/CyclicModuleRecord.cpp @@ -740,7 +740,7 @@ void CyclicModuleRecord::execute(JSGlobalObject* globalObject, JSPromise* capabi auto scope = DECLARE_THROW_SCOPE(vm); #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) + if (auto* compiled = AOT::compiledModule(vm, this)) RELEASE_AND_RETURN(scope, compiled->execute(globalObject, capability)); #endif #if ENABLE(WEBASSEMBLY) @@ -777,7 +777,7 @@ void CyclicModuleRecord::executeAsync(JSGlobalObject* globalObject) // 2. Assert: module.[[HasTLA]] is true. ASSERT(hasTLA()); #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(this)) + if (auto* compiled = AOT::compiledModule(vm, this)) RELEASE_AND_RETURN(scope, compiled->executeAsync(globalObject)); if (isCompiledOriginal()) RELEASE_AND_RETURN(scope, AOT::evaluateOriginalAsync(globalObject, uncheckedDowncast(this))); diff --git a/Source/JavaScriptCore/runtime/JSMicrotask.cpp b/Source/JavaScriptCore/runtime/JSMicrotask.cpp index 2a4ad3e710977..443ee3906eb98 100644 --- a/Source/JavaScriptCore/runtime/JSMicrotask.cpp +++ b/Source/JavaScriptCore/runtime/JSMicrotask.cpp @@ -1217,7 +1217,8 @@ static void runModuleRegistryFetchSettled(JSGlobalObject* globalObject, VM& vm, if (status == JSPromise::Status::Fulfilled) { auto moduleData = argument1; #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(moduleData)) { + auto* compiled = AOT::compiledModule(vm, moduleData); + if (compiled) { JSPromise* source = compiled->sourceAfterRelease(globalObject); if (scope.exception()) [[unlikely]] { modulePromise->rejectWithCaughtException(vm, scope); @@ -1228,10 +1229,7 @@ static void runModuleRegistryFetchSettled(JSGlobalObject* globalObject, VM& vm, return; } } -#endif -#if ENABLE(AOT) - auto* compiledData = dynamicDowncast(moduleData); - bool mayBeMade = compiledData && compiledData->isFileYetToBeEvaluated(); + const bool mayBeMade = compiled && compiled->isFileYetToBeEvaluated(); #endif JSPromise* makeModulePromise = entry->loader()->makeModule(globalObject, entry->key(), moduleData); if (scope.exception()) { @@ -1239,8 +1237,8 @@ static void runModuleRegistryFetchSettled(JSGlobalObject* globalObject, VM& vm, return; } #if ENABLE(AOT) - if (mayBeMade && modulePromise->status() == JSPromise::Status::Pending && makeModulePromise->status() == JSPromise::Status::Fulfilled && makeModulePromise->result() == JSValue(compiledData)) - compiledData->setIsMadeAndNotStored(true); + if (mayBeMade && modulePromise->status() == JSPromise::Status::Pending && makeModulePromise->status() == JSPromise::Status::Fulfilled && makeModulePromise->result() == JSValue(compiled)) + compiled->setIsMadeAndNotStored(true); #endif makeModulePromise->performPromiseThenWithInternalMicrotask(vm, InternalMicrotask::ModuleRegistryModuleSettled, modulePromise, entry); } else { @@ -1261,7 +1259,7 @@ static void runModuleRegistryModuleSettled(JSGlobalObject* globalObject, VM& vm, auto* modulePromise = uncheckedDowncast(argument0); auto status = static_cast(payload); #if ENABLE(AOT) - if (auto* compiled = status == JSPromise::Status::Fulfilled ? dynamicDowncast(argument1) : nullptr) + if (auto* compiled = status == JSPromise::Status::Fulfilled ? AOT::compiledModule(vm, argument1) : nullptr) compiled->setIsMadeAndNotStored(false); #endif #if USE(BUN_JSC_ADDITIONS) @@ -1358,7 +1356,7 @@ static void runModuleLoadStep(JSGlobalObject* globalObject, VM& vm, InternalMicr auto* module = downcast(argument1); context->module(vm, module); #if ENABLE(AOT) - if (auto* compiled = context->payload()->inherits() ? nullptr : dynamicDowncast(module)) + if (auto* compiled = AOT::compiledModule(vm, module); compiled && !context->payload()->inherits()) compiled->willBeLoadedByImport(); #endif JSPromise* requestedPromise = context->loader()->loadRequestedModules(globalObject, module, context->scriptFetcher(), vm.hasCompiledCode() && context->referrer().getModule() ? dynamicDowncast(context->payload()) : nullptr); @@ -1382,14 +1380,15 @@ static void runModuleLoadStep(JSGlobalObject* globalObject, VM& vm, InternalMicr if (status == JSPromise::Status::Fulfilled) { auto* module = context->module(); #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(module); compiled && compiled->takeExtraLoadStep()) { + auto* compiled = AOT::compiledModule(vm, module); + if (compiled && compiled->takeExtraLoadStep()) { JSPromise* delayedLoadPromise = JSPromise::create(vm, globalObject->promiseStructure()); delayedLoadPromise->markAsHandled(); delayedLoadPromise->fulfill(vm, module); delayedLoadPromise->performPromiseThenWithInternalMicrotask(vm, InternalMicrotask::ModuleLoadStep, loadPromise, context); return; } - if (auto* compiled = dynamicDowncast(module); compiled && context->referrer().isRealm() && compiled->takeMainModuleLoadStep()) { + if (compiled && context->referrer().isRealm() && compiled->takeMainModuleLoadStep()) { // From here on the entry point counts as loaded for every past and future importer. The caller that loaded the program is notified in the next step. JSPromise* importerLoadPromise = JSPromise::create(vm, globalObject->promiseStructure()); importerLoadPromise->markAsHandled(); @@ -1475,7 +1474,7 @@ static void runModuleLoadTopSettled(JSGlobalObject* globalObject, VM& vm, Intern // ModuleRegistryEntry::provideModule(): the entry already holds its record, nothing to provide. #if ENABLE(AOT) // No registry entry holds the record that the fetch hook returns for a compiled module yet. Without one the module would be fetched again. - if (!moduleData.inherits() || moduleData.inherits()) { + if (!moduleData.inherits() || AOT::compiledModule(vm, moduleData)) { #else if (!moduleData.inherits()) { #endif @@ -1695,7 +1694,7 @@ static void runModuleLoadLinkEvaluateSettled(JSGlobalObject* globalObject, VM& v return; } #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(record)) { + if (auto* compiled = AOT::compiledModule(vm, record)) { evaluatePromise = compiled->evaluateMainModule(evaluatePromise); if (scope.exception()) { resultPromise->rejectWithCaughtException(vm, scope); @@ -1796,7 +1795,7 @@ static void dynamicImportLoadSettled(JSGlobalObject* globalObject, VM& vm, JSVal // Step-6 linkAndEvaluateClosure #if ENABLE(AOT) - if (auto* compiled = vm.hasCompiledCode() ? dynamicDowncast(module) : nullptr; compiled && compiled->tryDeferForEarlierImports(dynamicPayload, deferred)) + if (auto* compiled = AOT::compiledModule(vm, module); compiled && compiled->tryDeferForEarlierImports(dynamicPayload, deferred)) return; #endif // 6.a. Let link be Completion(module.Link()). diff --git a/Source/JavaScriptCore/runtime/JSModuleEnvironment.cpp b/Source/JavaScriptCore/runtime/JSModuleEnvironment.cpp index 0faf08f5783a1..f16ed93a7908f 100644 --- a/Source/JavaScriptCore/runtime/JSModuleEnvironment.cpp +++ b/Source/JavaScriptCore/runtime/JSModuleEnvironment.cpp @@ -158,7 +158,7 @@ bool JSModuleEnvironment::getOwnPropertySlot(JSObject* cell, JSGlobalObject* glo } #endif #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(resolution.moduleRecord)) { + if (auto* compiled = AOT::compiledModule(vm, resolution.moduleRecord)) { bool isRead = slot.internalMethodType() == PropertySlot::InternalMethodType::Get || slot.internalMethodType() == PropertySlot::InternalMethodType::GetOwnProperty; JSValue value = jsUndefined(); if (isRead) { diff --git a/Source/JavaScriptCore/runtime/JSModuleLoader.cpp b/Source/JavaScriptCore/runtime/JSModuleLoader.cpp index be6ebd055e471..7f0395e952345 100644 --- a/Source/JavaScriptCore/runtime/JSModuleLoader.cpp +++ b/Source/JavaScriptCore/runtime/JSModuleLoader.cpp @@ -936,7 +936,7 @@ JSPromise* JSModuleLoader::hostLoadImportedModule(JSGlobalObject* globalObject, if (fetchPromise->status() == JSPromise::Status::Pending) { #if ENABLE(AOT) // A compiled module already has the record for each of its requests, so there is nothing to fetch. - auto* compiled = record && !moduleRequest.m_attributes ? dynamicDowncast(record) : nullptr; + auto* compiled = record && !moduleRequest.m_attributes ? AOT::compiledModule(vm, record) : nullptr; AbstractModuleRecord* requested = compiled ? compiled->findRequestedRecord(resolved) : nullptr; if (Exception* exception = scope.exception()) [[unlikely]] { TRY_CLEAR_EXCEPTION(scope, nullptr); @@ -1036,7 +1036,7 @@ JSPromise* JSModuleLoader::hostLoadImportedModule(JSGlobalObject* globalObject, JSPromise* promise = nullptr; #if ENABLE(AOT) // A compiled module already knows the record of each compiled module it requests. This promise replaces the one the host would return. - if (auto* compiled = record && !moduleRequest.m_attributes ? dynamicDowncast(record) : nullptr) { + if (auto* compiled = record && !moduleRequest.m_attributes ? AOT::compiledModule(vm, record) : nullptr) { AbstractModuleRecord* requested = compiled->nextRequestedRecord(globalObject, resolved); if (scope.exception()) [[unlikely]] { promise = JSPromise::create(vm, globalObject->promiseStructure()); @@ -1149,7 +1149,7 @@ void JSModuleLoader::innerModuleLoading(JSGlobalObject* globalObject, ModuleGrap // 2.a. Append module to state.[[Visited]]. state->appendVisited(vm, cyclic); #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(cyclic)) { + if (auto* compiled = AOT::compiledModule(vm, cyclic)) { compiled->willLoadRequests(*state); RETURN_IF_EXCEPTION(scope, void()); // A CommonJS module that this module imports ran inside willLoadRequests() and already resumed this load. @@ -1195,7 +1195,7 @@ void JSModuleLoader::innerModuleLoading(JSGlobalObject* globalObject, ModuleGrap unsigned loadedModulesCountBefore = module->loadedModules().size(); bool useImportMap = true; #if ENABLE(AOT) - auto* compiled = dynamicDowncast(cyclic); + auto* compiled = AOT::compiledModule(vm, cyclic); useImportMap = !compiled; uint8_t flagsBefore = compiled ? compiled->willLoadImportedModule(request.m_specifier) : 0; #endif diff --git a/Source/JavaScriptCore/runtime/JSModuleNamespaceObject.cpp b/Source/JavaScriptCore/runtime/JSModuleNamespaceObject.cpp index 70a2c96a7db95..ca48d4ac0d401 100644 --- a/Source/JavaScriptCore/runtime/JSModuleNamespaceObject.cpp +++ b/Source/JavaScriptCore/runtime/JSModuleNamespaceObject.cpp @@ -212,7 +212,7 @@ bool JSModuleNamespaceObject::getOwnPropertySlotCommon(JSGlobalObject* globalObj case PropertySlot::InternalMethodType::GetOwnProperty: case PropertySlot::InternalMethodType::Get: { #if ENABLE(AOT) - if (auto* compiled = dynamicDowncast(exportEntry.moduleRecord.get())) { + if (auto* compiled = AOT::compiledModule(vm, exportEntry.moduleRecord.get())) { JSValue value = exportEntry.localName == vm.propertyNames->starNamespacePrivateName ? JSValue(compiled->moduleNamespaceObject(globalObject, AbstractModuleRecord::ModulePhase::Evaluation)) : compiled->readExport(globalObject, exportEntry.localName, exportEntry.compiledExportIndex); diff --git a/Source/JavaScriptCore/runtime/JSScope.cpp b/Source/JavaScriptCore/runtime/JSScope.cpp index 66cd977e8f24e..8ba5f49a74df7 100644 --- a/Source/JavaScriptCore/runtime/JSScope.cpp +++ b/Source/JavaScriptCore/runtime/JSScope.cpp @@ -113,7 +113,7 @@ static inline bool abstractAccess(JSGlobalObject* globalObject, JSScope* scope, } #endif #if ENABLE(AOT) - if (importedRecord->inherits()) { + if (AOT::compiledModule(vm, importedRecord)) { op = ResolveOp(Dynamic, 0, nullptr, nullptr, nullptr, 0); return true; }