[JSC] AOT: iterators of String objects, long literals, loaders of built-in modules

Source/JavaScriptCore/aot/analysis/AOTUnspecifiedValuePaths.cpp

@@ -162,6 +162,16 @@ class Facts {
         return changed;
     }
 
+    bool disagreesWith(const Facts& other, NOESCAPE const Invocable<bool(ValueID)> auto& isRelevant) const
+    {
+        return std::ranges::any_of(m_sorted, [&](const Fact& fact) {
+            if (fact.testedType || fact.integers.isEmpty() || !isRelevant(fact.value))
+                return false;
+            const Integers* others = other.find(fact.value);
+            return others && !others->isEmpty() && fact.integers.intersectedWith(*others).isEmpty();
+        });
+    }
+
     size_t size() const { return m_sorted.size(); }
     const Fact& operator[](size_t index) const { return m_sorted[index]; }
 
@@ -634,10 +644,17 @@ class MergingWalker {
             m_queue.append({ m_analyses.cfg().reversePostOrderIndex(block), stateIndex });
             std::ranges::push_heap(m_queue, std::greater { });
         };
+        // States that disagree about a value defined in another block stay separate, so a later branch on that value sends each one down its own edge.
+        AOT_THRESHOLD(size_t, maxSeparateStates, 8);
+        const UseLists& useLists = m_analyses.useLists();
+        auto isDefinedInAnotherBlock = [&](ValueID id) { return useLists.blockOf(id) != block; };
+        size_t numberOfStates = 0;
         for (uint32_t stateIndex : m_statesOfBlock[block.index()]) {
             WalkState& state = m_states[stateIndex];
             if (state.marked != marked)
                 continue;
+            if (++numberOfStates < maxSeparateStates && state.facts.disagreesWith(facts, isDefinedInAnotherBlock))
+                continue;
             if (state.facts.mergeWith(facts) && !state.isQueued)
                 queue(stateIndex);
             return;

Source/JavaScriptCore/aot/builtins/AOTResolveBuiltins.cpp

@@ -9,6 +9,7 @@
 #if ENABLE(AOT)
 
 #include "AOTBuildContext.h"
+#include "AOTCoroutines.h"
 #include "AOTFunctionAnalyses.h"
 #include "AOTPropertyAccessCache.h"
 #include "AOTSimplifyBuiltinCallsInternal.h"
@@ -266,31 +267,17 @@ PassOutcome BuiltinResolver::run()
     return PassOutcome::Changed;
 }
 
-static Value makeIteratorResultObject(const Program& program, const Value& intrinsic)
-{
-    LayoutID layoutID = program.layoutOf(BuiltinLayouts::IteratorResult);
-    const Layout& layout = program.at(layoutID);
-    std::optional<uint32_t> valueField = layout.findField(program.keyOf(BuiltinNames::value));
-    std::optional<uint32_t> doneField = layout.findField(program.keyOf(BuiltinNames::done));
-    RELEASE_ASSERT(valueField && doneField);
-
-    Value object = IRBuilder::make(Opcode::NewObject);
-    object.setLayout(layoutID);
-    object.setFields(std::array { *valueField, *doneField });
-    object.setValuesOperands(std::array { intrinsic.valueOperand(), intrinsic.doneOperand() });
-    object.setAllocationSite(intrinsic.allocationSite());
-    return object;
-}
-
 static bool allocateIteratorResultsAsObjects(FunctionPassContext& context)
 {
     const Function& function = context.function;
     Vector<ValueID> intrinsics;
     for (const ValueSite& site : context.sitesIn(SiteList::IteratorResults))
         intrinsics.append(site.value);
 
-    for (ValueID intrinsic : intrinsics)
-        replaceKeepingType(context, intrinsic, makeIteratorResultObject(context.program, function.at(intrinsic)));
+    for (ValueID id : intrinsics) {
+        const Value& intrinsic = function.at(id);
+        replaceKeepingType(context, id, makeIteratorResultObject(context.program, intrinsic.valueOperand(), intrinsic.doneOperand(), intrinsic.allocationSite()));
+    }
     if (!intrinsics.isEmpty())
         context.analyses.didChangeValues();
     return !intrinsics.isEmpty();

Source/JavaScriptCore/aot/passes/AOTCoroutines.cpp

@@ -15,6 +15,8 @@
 #include "AOTEffectsCheck.h"
 #include "AOTEffectsOfProtocols.h"
 #include "AOTFlowCoroutines.h"
+#include "AOTFlowResults.h"
+#include "AOTFlowUnseenCode.h"
 #include "AOTFunctionAnalyses.h"
 #include "AOTFunctionEditing.h"
 #include "AOTFuseGeneratorLoops.h"
@@ -30,6 +32,7 @@
 #include "AOTValueSubstitution.h"
 #include "AOTVector.h"
 #include <algorithm>
+#include <array>
 #include <initializer_list>
 #include <optional>
 #include <ranges>
@@ -91,6 +94,22 @@ ValueID appendAsyncIteratorStep(IRBuilder& builder, ValueID iterator, ValueID se
     return builder.append(Opcode::StepAsyncGenerator, { iterator, sent, driver });
 }
 
+Value makeIteratorResultObject(const Program& program, ValueID value, ValueID done, AllocationSiteID site)
+{
+    LayoutID layoutID = program.layoutOf(BuiltinLayouts::IteratorResult);
+    const Layout& layout = program.at(layoutID);
+    std::optional<uint32_t> valueField = layout.findField(program.keyOf(BuiltinNames::value));
+    std::optional<uint32_t> doneField = layout.findField(program.keyOf(BuiltinNames::done));
+    RELEASE_ASSERT(valueField && doneField);
+
+    Value object = IRBuilder::make(Opcode::NewObject);
+    object.setLayout(layoutID);
+    object.setFields(std::array { *valueField, *doneField });
+    object.setValuesOperands(std::array { value, done });
+    object.setAllocationSite(site);
+    return object;
+}
+
 // A ramp takes over the id and the callers of its source, so what is known about those callers carries over.
 static constexpr OptionSet<FunctionCapabilities> capabilitiesRampsInherit {
     FunctionCapabilities::MayChangeSignature,
@@ -696,8 +715,15 @@ static void retypeCallers(ProgramEditor& editor, BuildContext& build, const Vect
     });
 }
 
+static bool loadsModulesByName(const FlowResults& flow)
+{
+    return !flow.hasResults() || std::ranges::any_of(flow.unseenCode(), [](const UnseenCodeRecord& record) {
+        return loadsModulesByName(record.cause);
+    });
+}
+
 // A require() evaluates the ES module that it names and what that module imports.
-static void markModulesEvaluatedByRequire(ProgramEditor& editor, const ParallelLoops& loops)
+static void markModulesEvaluatedByRequire(ProgramEditor& editor, const FlowResults& flow, const ParallelLoops& loops)
 {
     const Program& program = editor.program();
     bool someModuleAwaits = std::ranges::any_of(program.modules, [](const Module& module) {
@@ -720,6 +746,11 @@ static void markModulesEvaluatedByRequire(ProgramEditor& editor, const ParallelL
                 work.append(request.target.index());
         }
     }
+    // A name computed at run time finds an entry point. A program with one entry point has begun it before any require() runs.
+    if (program.entries.size() > 1 && loadsModulesByName(flow)) {
+        for (const Entry& entry : program.entries)
+            work.append(entry.module.index());
+    }
     BitVector seen(program.modules.size());
     while (!work.isEmpty()) {
         uint32_t index = work.takeLast();
@@ -740,7 +771,7 @@ void splitCoroutines(ProgramEditor& editor, const OptimizationInputs& inputs, co
     });
     if (coroutines.isEmpty())
         return;
-    markModulesEvaluatedByRequire(editor, build.parallelLoops());
+    markModulesEvaluatedByRequire(editor, inputs.flow, build.parallelLoops());
     Vector<CoroutinePlan> plans(coroutines.size(), [&](size_t index) {
         CoroutinePlan plan;
         plan.record.kind = *coroutineKindOf(program.functions[coroutines[index]]);
@@ -1329,11 +1360,8 @@ static void expandAwaitOfGeneratorStep(FunctionPassContext& context, IRBuilder&
     if (!site.resultReads) {
         builder.endExpansion(expansion, convertTo(builder, stepped, DeclaredType { .type = type }));
 
-        // What CreateIterResultObject makes: an ordinary object with the two as its own data properties, in this order.
         builder.moveToEndOf(blocks.notTaken);
-        ValueID object = builder.append(Opcode::NewDictionary, { });
-        appendWithKey(Opcode::PropDefine, { object, stepped }, valueKey);
-        appendWithKey(Opcode::PropDefine, { object, appendStatusTest(AsyncGeneratorStepStatus::Completed) }, doneKey);
+        ValueID object = builder.append(makeIteratorResultObject(context.program, stepped, appendStatusTest(AsyncGeneratorStepStatus::Completed)));
         builder.endExpansion(expansion, convertTo(builder, object, DeclaredType { .type = type }));
         return;
     }

Source/JavaScriptCore/aot/passes/AOTCoroutines.h

@@ -43,6 +43,9 @@ unsigned stepAwaitedAsyncGenerators(FunctionPassContext&);
 // For an unsplit async function or async generator, or the body of one. The results are those of StepAsyncGenerator.
 ValueID appendAsyncIteratorStep(IRBuilder&, ValueID iterator, ValueID sent);
 
+// What CreateIterResultObject makes.
+Value makeIteratorResultObject(const Program&, ValueID value, ValueID done, AllocationSiteID = { });
+
 } } } // namespace JSC::AOT::Typed
 
 #endif // ENABLE(AOT)