Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
22 commits
Select commit Hold shift + click to select a range
ce0fab5
AOT: a row that is also a key is not a list of elements
Jarred-Sumner Nov 16, 2026
26c7380
AOT: the call behind a copied head asks again whether its entry takes…
Jarred-Sumner Nov 16, 2026
bcc9057
AOT: an ES file that is required during a load reads what a CommonJS …
Jarred-Sumner Nov 16, 2026
0258757
AOT: a generator that a loop leaves can be resumed
Jarred-Sumner Nov 16, 2026
4cc29be
AOT test runs: mocks that end, and spies beside modules that are mocked
Jarred-Sumner Nov 16, 2026
04f3922
AOT: a check of the compiler knows parameters that nothing is passed to
Jarred-Sumner Nov 16, 2026
1fcc830
AOT: the file around a function may stand for it in a require()
Jarred-Sumner Nov 16, 2026
477bfc6
AOT: a required ES module that exports __esModule can be extended
Jarred-Sumner Nov 16, 2026
4601861
AOT: a list of 2^28 characters is made
Jarred-Sumner Nov 16, 2026
b91d11d
AOT: joined lists and lists of constants are compared with memory und…
Jarred-Sumner Nov 16, 2026
1e0a2cd
AOT: a loop behind a branch that decides nothing carries its list
Jarred-Sumner Nov 16, 2026
ff7da89
AOT: a file that threw behind a require() that it had answered is a c…
Jarred-Sumner Nov 16, 2026
fdecacc
AOT: the template object of a site is one object
Jarred-Sumner Nov 16, 2026
fdd6796
AOT: positions that are integers of 53 bits are folded into nests of …
Jarred-Sumner Nov 16, 2026
6c19f1a
AOT test runs: release what test files that have ended have loaded
Jarred-Sumner Nov 16, 2026
c09abea
AOT: order files of other folders, of files that were moved and of ot…
Jarred-Sumner Nov 16, 2026
5614033
AOT: an iteration over matches is saved with its generator
Jarred-Sumner Nov 16, 2026
e6db644
AOT: more of what the compiler knows is asked under proof checks
Jarred-Sumner Nov 16, 2026
22236da
AOT: interpreted code and objects that are also used as tables
Jarred-Sumner Nov 16, 2026
e9ce1a8
AOT: a name of the order file's own
Jarred-Sumner Nov 16, 2026
2c8ad18
The capacity of an array that is added to at its start doesn't grow w…
Jarred-Sumner Nov 16, 2026
e654330
AOT: a field that a row lacks is undefined in a sum with a field that…
Jarred-Sumner Nov 16, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -118,7 +118,9 @@ void ArrayBuiltinEmitter::generateArrayConcat(const InlineCall& call)
Vector<std::optional<Operand>, maxConcatenatedArrays> rawItems;
for (unsigned i = 0; i < arrays.size(); ++i) {
rawItems.append(arrays[i] ? std::nullopt : elements().rawElementToStore(made, call.argument(i - 1), miss));
if (!arrays[i] && !rawItems.last()) {
if (rawItems.last())
elements().stopWhereHoleWouldBeStored(call.context(), made, *rawItems.last());
else if (!arrays[i]) {
m_out.jump(miss);
m_out.appendTo(newBlock());
}
Expand Down Expand Up @@ -181,6 +183,7 @@ Integer ArrayBuiltinEmitter::clampToLength(Integer relative, Integer length)
void ArrayBuiltinEmitter::storeItem(const InlineCall& call, const ArrayStorageForm& form, ArrayElements target, Integer position, ValueID item)
{
if (std::optional<Operand> rawElement = elements().rawElementToStore(form, item, missBlockOf(call))) {
elements().stopWhereHoleWouldBeStored(call.context(), form, *rawElement);
elements().storeRawElement(form, target, position, *rawElement);
return;
}
Expand Down Expand Up @@ -279,6 +282,7 @@ std::optional<ArrayBuiltinEmitter::RawItems> ArrayBuiltinEmitter::rawItemsToInse
m_out.jump(doesNotFit);
return std::nullopt;
}
elements().stopWhereHoleWouldBeStored(call.context(), form, *rawElement);
inserted.append(*rawElement);
}
return inserted;
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -302,6 +302,7 @@ void ArrayIntrinsicEmitter::putNumberInBounds(const ValueContext& value, const A
fail(value, InternalErrorKind::UnsupportedConversion);
return;
}
elements().stopWhereHoleWouldBeStored(value, form, *rawElement);
elements().storeRawElement(form, storage, positionThatLibraryVouchesFor(value, storage, form, AccessVouchedFor::Writes), *rawElement);
if (!doesNotFit->numberOfIncomingEdges())
return;
Expand Down Expand Up @@ -492,6 +493,7 @@ void ArrayIntrinsicEmitter::generateTryPutByValDirect(const ValueContext& value)
ArrayElements found = elements().elementsOf(array);
branchUnless(below(index, elements().publicLength(found)), otherwise);
if (std::optional<Operand> element = elements().rawElementToStore(held, stored, otherwise)) {
elements().stopWhereHoleWouldBeStored(value, held, *element);
elements().storeRawElement(held, found, index, *element);
isStored.add(boolean(true));
} else
Expand Down Expand Up @@ -553,6 +555,7 @@ void ArrayIntrinsicEmitter::generateTryPutByValDirect(const ValueContext& value)
branchUnless(elements().hasWritableShape(elements().indexingMode(array, IndexingShapeAndWritabilityMask), form), otherwise);
ArrayElements storage = elements().elementsOf(array);
branchUnless(below(index, elements().publicLength(storage)), otherwise);
elements().stopWhereHoleWouldBeStored(value, form, *rawElement);
elements().storeRawElement(form, storage, index, *rawElement);
if (form.holdsCells)
barrierAfterStore(value, array, typeOf(stored));
Expand Down
16 changes: 12 additions & 4 deletions Source/JavaScriptCore/aot/codegen/AOTCodeGenerator.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -151,6 +151,8 @@ GenerationResult CodeGenerator::run()

m_generatesWatched = m_watchesOperations || m_looksBehindEachOperation;
definePinnedValues(m_out, m_pinned);
if (!m_checksEffects && code().opcodesOfValues().contains(Opcode::TakeGeneratorLeftInPlace))
emitter<OperatorEmitter>().bigIntValues();
if (!m_checksEffects && BigIntValues::mayGoAroundLoops(code(), order()))
emitter<OperatorEmitter>().bigIntValues();
emitter<EntryEmitter>().generateEntries();
Expand Down Expand Up @@ -2135,8 +2137,11 @@ bool CodeGenerator::isJoinWithRareCode(BlockID join) const
unsigned edges = 0;
unsigned rareEdges = 0;
for (EdgeID id = block.firstEdgeIn(); id; id = code().at(id).nextInto()) {
const Block& from = code().at(code().at(id).from);
if (from.terminator.kind != TerminatorKind::Jump || !code().isReached(code().at(id).from))
BlockID source = code().at(id).from;
if (!code().isReached(source))
continue;
const Block& from = code().at(source);
if (from.terminator.kind != TerminatorKind::Jump)
return false;
++edges;
rareEdges += from.frequency == BlockFrequency::Rare;
Expand All @@ -2153,7 +2158,9 @@ bool CodeGenerator::isBackEdgeOfSimpleLoop(BlockID from, BlockID head)
BlockID entering;
for (EdgeID id = block.firstEdgeIn(); id; id = code().at(id).nextInto()) {
BlockID source = code().at(id).from;
if (code().at(source).terminator.kind != TerminatorKind::Jump || !code().isReached(source))
if (!code().isReached(source))
continue;
if (code().at(source).terminator.kind != TerminatorKind::Jump)
return false;
++edges;
if (source != from)
Expand All @@ -2166,7 +2173,8 @@ bool CodeGenerator::isKnownAtEveryEdgeInto(BlockID block, ValueID list)
{
BlockID home = code().blockOf(list);
for (EdgeID id = code().at(block).firstEdgeIn(); id; id = code().at(id).nextInto()) {
if (!blockDominates(home, code().at(id).from))
BlockID source = code().at(id).from;
if (code().isReached(source) && !blockDominates(home, source))
return false;
}
return true;
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -690,7 +690,7 @@ bool MoveLoopFinder::finish()
return false;
}
for (MoveLoop::Read& read : m_found.reads) {
if ((read.isReadAgain && (read.isMoved || read.isKey || read.isNumber)) || (read.isRow && read.isNumber))
if ((read.isReadAgain && (read.isMoved || read.isKey || read.isNumber)) || (read.isRow && (read.isNumber || read.isKey)))
return false;
if (!read.isRow)
continue;
Expand Down
35 changes: 29 additions & 6 deletions Source/JavaScriptCore/aot/codegen/AOTCodeGeneratorSumNests.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -94,6 +94,8 @@ static constexpr int64_t mostColumns = 1 << 20;
static constexpr int64_t fewestTerms = 8;
static constexpr int64_t mostTerms = 1 << 20;
static constexpr int64_t greatestStep = int64_t { 1 } << 32;
static constexpr int64_t greatestStepOfInteger = int64_t { 1 } << 53;
static constexpr int64_t greatestDistance = int64_t { 1 } << 55;
static constexpr size_t mostSums = 2;
static constexpr size_t mostReads = 4;
static constexpr unsigned mostDepth = 16;
Expand Down Expand Up @@ -153,6 +155,12 @@ class LinearIntegers {
std::swap(left, right);
if (!right.inner.isZero() || !right.outer.isZero())
return std::nullopt;
bool overflows = right.first.isConstant && std::ranges::any_of(std::array { &left.first, &left.inner, &left.outer }, [&](const KnownInteger* factor) {
int64_t product;
return factor->isConstant && __builtin_mul_overflow(factor->constant, right.first.constant, &product);
});
if (overflows)
return std::nullopt;
return LinearInteger { multiply(left.first, right.first), multiply(left.inner, right.first), multiply(left.outer, right.first) };
}
KnownInteger negate(const KnownInteger& integer) const { return multiply(integer, constantOf(-1)); }
Expand Down Expand Up @@ -188,11 +196,16 @@ class LinearIntegers {
if (m_checksProofs || range.minimum < std::numeric_limits<int32_t>::min() || range.maximum > std::numeric_limits<int32_t>::max())
wrapped.append(linear);
}
static bool hasStepsBelow(int64_t limit, const LinearInteger& linear)
{
return std::ranges::all_of(std::array { &linear.first, &linear.inner, &linear.outer }, [&](const KnownInteger* integer) {
return !integer->isConstant || (integer->constant < limit && integer->constant > -limit);
});
}
std::optional<LinearInteger> multiplyInt32s(const Operation& product, const LinearInteger& left, const LinearInteger& right)
{
std::optional<LinearInteger> result = multiply(left, right);
auto isLongStep = [](const KnownInteger& integer) { return integer.isConstant && std::abs(integer.constant) >= int64_t { 1 } << 32; };
if (!result || isLongStep(result->first) || isLongStep(result->inner) || isLongStep(result->outer))
if (!result || !hasStepsBelow(greatestStep, *result))
return std::nullopt;
for (auto [factor, linear] : { std::pair(product.leftOperand(), &left), std::pair(product.rightOperand(), &right) }) {
if (m_code.isConstant(factor) || m_generator.representationOf(factor) == Representation::Int32)
Expand Down Expand Up @@ -346,7 +359,7 @@ std::optional<LinearInteger> LinearIntegers::find(ValueID value, unsigned depth)
return linear;
}
std::optional<LinearInteger> linear = findAnew(value, depth);
if (linear && std::ranges::any_of(std::array { linear->first, linear->inner, linear->outer }, [](const KnownInteger& integer) { return integer.isConstant && std::abs(integer.constant) >= greatestStep; }))
if (linear && !hasStepsBelow(m_generator.representationOf(value) == Representation::Int64 && isInteger(value) ? greatestStepOfInteger : greatestStep, *linear))
return std::nullopt;
if (linear)
m_known.append({ value, *linear });
Expand Down Expand Up @@ -437,6 +450,8 @@ std::optional<LinearInteger> LinearIntegers::findAnew(ValueID value, unsigned de
std::optional<LinearInteger> linear = operandAt(operation.leftOperand());
if (!linear || !amount || *amount < 0 || *amount > 16)
return std::nullopt;
if (!hasStepsBelow(greatestStep, *linear))
return std::nullopt;
requireInt32(*linear, operation.leftOperand());
LinearInteger result { shiftLeft(linear->first, *amount), shiftLeft(linear->inner, *amount), shiftLeft(linear->outer, *amount) };
wrapped.append(result);
Expand Down Expand Up @@ -1436,6 +1451,7 @@ class SumNestEmitter {
void emitExits();
void name(ValueID, LValue);
LValue numberOfIterations(const SumNest::CountedTest&, LValue first);
void leaveUnlessInReach(const KnownInteger& step, LValue iterations);
std::pair<LValue, LValue> extremesOf(const LinearInteger&);
void requireInt32(const LinearInteger&);
LValue columnsWithAnswer(const SumNest::ColumnTest&, LValue columns);
Expand Down Expand Up @@ -1534,20 +1550,28 @@ LValue SumNestEmitter::numberOfIterations(const SumNest::CountedTest& test, LVal
return test.added ? m_out.add(number, test.added) : number;
}

void SumNestEmitter::leaveUnlessInReach(const KnownInteger& step, LValue iterations)
{
if (!step.isConstant)
leaveUnless(m_out.below(m_out.add(m_integers.valueOf(step), greatestStep), m_out.constInt64(2 * greatestStep)), m_out.int64Zero);
else if (step.constant >= greatestStep || step.constant <= -greatestStep)
leaveUnless(m_out.lessThanOrEqual(iterations, m_out.constInt64(greatestDistance / std::abs(step.constant))), m_out.int64Zero);
}

std::pair<LValue, LValue> SumNestEmitter::extremesOf(const LinearInteger& linear)
{
LValue least = m_integers.valueOf(linear.first);
LValue greatest = least;
for (auto [step, last] : { std::pair(&linear.inner, m_lastTerm), std::pair(&linear.outer, m_lastColumn) }) {
if (step->isZero())
continue;
leaveUnlessInReach(*step, last);
LValue distance = m_out.mul(m_integers.valueOf(*step), last);
if (step->isConstant) {
LValue& moved = step->constant < 0 ? least : greatest;
moved = m_out.add(moved, distance);
continue;
}
leaveUnless(m_out.below(m_out.add(m_integers.valueOf(*step), greatestStep), m_out.constInt64(2 * greatestStep)), m_out.int64Zero);
LValue isNegative = m_out.lessThan(distance, m_out.int64Zero);
least = m_out.add(least, m_out.select(isNegative, distance, m_out.int64Zero));
greatest = m_out.add(greatest, m_out.select(isNegative, m_out.int64Zero, distance));
Expand Down Expand Up @@ -1579,8 +1603,7 @@ LValue SumNestEmitter::columnsWithAnswer(const SumNest::ColumnTest& test, LValue
leaveUnless(m_out.greaterThan(columnsInRoom, m_out.int64Zero), m_out.int64Zero);
if (step.isConstant && step.constant >= 0)
return columns;
if (!step.isConstant)
leaveUnless(m_out.below(m_out.add(m_integers.valueOf(step), greatestStep), m_out.constInt64(2 * greatestStep)), m_out.int64Zero);
leaveUnlessInReach(step, columns);
LValue roomOfLast = m_out.add(columnsInRoom, m_out.mul(m_integers.valueOf(step), m_out.sub(columns, m_out.constInt64(1))));
leaveUnless(m_out.greaterThan(roomOfLast, m_out.int64Zero), m_out.int64Zero);
return columns;
Expand Down
1 change: 1 addition & 0 deletions Source/JavaScriptCore/aot/codegen/AOTCompileFunctions.h
Original file line number Diff line number Diff line change
Expand Up @@ -24,6 +24,7 @@ CompiledCode generateCode(const CodeGenerationWorker&, const CodeGenerationInput

class BodyIndex;
bool hasStraightForm(const CodeGenerationInputs&, CodeUnit, const BodyIndex&);
bool canEmitResumeBody(const CodeGenerationWorker&, const CodeGenerationInputs&, FunctionID, const BodyIndex&, CodeGenerationTotals&);
std::optional<CompiledCode> generateStraightCode(const CodeGenerationWorker&, const CodeGenerationInputs&, const Code&, const BodyIndex&, CodeGenerationTotals&);
std::optional<CompiledCode> generateEntryWrittenByHand(const CodeGenerationWorker&, const CodeGenerationInputs&, const Code&, NOESCAPE const ScopedLambda<TypeID(unsigned)>& typeAskedOfEntryParameter, CodeGenerationTotals&, bool nobodyEnters);

Expand Down
21 changes: 21 additions & 0 deletions Source/JavaScriptCore/aot/codegen/AOTFunctionCodeGenerator.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -9,6 +9,7 @@
#if ENABLE(AOT)

#include "AOTCodeDescription.h"
#include "AOTCompileUnit.h"
#include "AOTCurrentWork.h"
#include "AOTEntryEmitter.h"
#include "AOTFunctionKinds.h"
Expand Down Expand Up @@ -69,6 +70,7 @@ Machine::ProcedureTraits machineTraitsOf(const BuildContext& build, const CodeGe
.shouldAssumeClearUpperHalves = hasFlag(build.options().injectedFaults, Wire::FaultInjection::AssumeClearUpperHalves),
.shouldIgnoreCollectorSpillReads = hasFlag(build.options().injectedFaults, Wire::FaultInjection::IgnoreCollectorSpillReads),
.notesRangesOfOrigins = hasFlag(build.options().reports, ReportSet::Flow) || !build.options().logging.mapFilePath.isNull(),
.checksProofs = !!sourcesOfProofsCheckedUnder(build.options().testing),
.features = build.targetFeatures(),
};
}
Expand Down Expand Up @@ -256,6 +258,14 @@ std::optional<CompiledCode> FunctionCodeGenerator::runStraight(const BodyIndex&
return code;
}

bool FunctionCodeGenerator::canEmitStraight(const BodyIndex& index)
{
StraightEmitter emitter(m_worker.build, m_worker.types, m_inputs, m_code.unit(), index, m_records, m_worker.arena);
ArgumentLocations locations = m_inputs.plan.conventions().locationsOf(m_inputs.program, m_code.unit());
emitter.generate(m_jit, locations, 0);
return !emitter.hasFailed();
}

CompiledCode FunctionCodeGenerator::runEntryWrittenByHand(std::span<const QuestionOfEntry> questions, bool nobodyEnters)
{
CodeUnit unit = m_code.unit();
Expand Down Expand Up @@ -411,6 +421,17 @@ bool hasStraightForm(const CodeGenerationInputs& inputs, CodeUnit unit, const Bo
return StraightEmitter::covers(inputs, unit, index);
}

bool canEmitResumeBody(const CodeGenerationWorker& worker, const CodeGenerationInputs& inputs, FunctionID function, const BodyIndex& index, CodeGenerationTotals& totals)
{
CodeUnit unit { function, CodeRole::SlowBody };
if (!StraightEmitter::covers(inputs, unit, index))
return false;
Code code;
code.reset(unit);
FunctionCodeGenerator generator(worker, inputs, code, totals);
return generator.canEmitStraight(index);
}

std::optional<CompiledCode> generateStraightCode(const CodeGenerationWorker& worker, const CodeGenerationInputs& inputs, const Code& code, const BodyIndex& index, CodeGenerationTotals& totals)
{
worker.arena.reset();
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -27,6 +27,7 @@ class FunctionCodeGenerator {

CompiledCode run();
std::optional<CompiledCode> runStraight(const BodyIndex&);
bool canEmitStraight(const BodyIndex&);
CompiledCode runEntryWrittenByHand(std::span<const QuestionOfEntry>, bool nobodyEnters);

private:
Expand Down
37 changes: 36 additions & 1 deletion Source/JavaScriptCore/aot/codegen/AOTSavedFrameEmitter.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -1452,6 +1452,18 @@ void SavedFrameEmitter::generateNewHeapWords(const ValueContext& value)
define(value, boxCell(frame));
}

void SavedFrameEmitter::generateNewSuspendedIteration(const ValueContext& value)
{
CellPointer state = callOperation<CellPointer>(value, RuntimeOperation::NewSuspendedIteration, { in<Boxed>(value->subjectOperand()), in<Boxed>(value->positionOperand()), in<Boxed>(value->tableOperand()), word32(static_cast<int32_t>(value->suspendedKind())), word32(value->positionIsBeforeStep()) }, { .isOnRarePath = true });
define(value, boxCell(state));
}

void SavedFrameEmitter::generateNewSuspendedEnumeration(const ValueContext& value)
{
CellPointer state = callOperation<CellPointer>(value, RuntimeOperation::NewSuspendedEnumeration, { in<CellPointer>(value->enumeratorOperand()), in<Boxed>(value->positionOperand()) }, { .isOnRarePath = true });
define(value, boxCell(state));
}

void SavedFrameEmitter::generateGetHeapFrameWord(const ValueContext& value)
{
if (Machine::StackSlot* slot = slotOfHeapWordsInFrame(value->frameOperand())) {
Expand Down Expand Up @@ -1479,6 +1491,14 @@ void SavedFrameEmitter::generatePutHeapFrameWord(const ValueContext& value)
emitter<BarrierEmitter>().barrierAfterStore(value, frame, storedType);
}

void SavedFrameEmitter::generatePutHeapFrameScope(const ValueContext& value)
{
CellPointer frame = unboxCell(in<Boxed>(value->frameOperand()));
CellPointer scope = in<CellPointer>(value->scopeOperand());
m_out.store64(boxCell(scope).value(), m_out.address(m_heaps.entire(AbstractHeap::InternalFields), frame.value(), offsetOfWordInHeapFrame(value->index())));
emitter<BarrierEmitter>().barrierAfterStore(value, frame, typeOf(value->scopeOperand()));
}

bool SavedFrameEmitter::findBlocksBehindFirstYield()
{
for (BlockID block : generator().order()) {
Expand Down Expand Up @@ -2726,7 +2746,22 @@ void SavedFrameEmitter::generateGetGeneratorPrototype(const ValueContext& value)

void SavedFrameEmitter::generateTakeGeneratorLeftInPlace(const ValueContext& value)
{
define(value, callOperation<Boxed>(value, RuntimeOperation::TakeGeneratorLeftInPlace, { in<CellPointer>(value->holderOperand()), word32(value->leavesAtOnce()) }, { .isOnRarePath = true }));
static_assert(SavedFrame::generatorWord == GeneratorFrameLayout::generatorWord);
CellPointer holder(m_out.intPtrZero);
if (ValueID held = value->holderOperand())
holder = in<CellPointer>(held);
CellPointer words(m_out.intPtrZero);
Pointer resumeAddress(m_out.intPtrZero);
if (ValueID held = value->wordsOperand()) {
words = unboxCell(in<Boxed>(held));
Machine::PatchOperation* patch = m_out.patchpoint(Machine::pointerType());
patch->effects = Machine::Effects::none();
patch->setGenerator([records = &m_records, unit = CodeUnit { value->function(), CodeRole::SlowBody }](CCallHelpers&, const Machine::PatchParameters& params) {
records->stubCalls.moveAddressOfFunction(unit, primaryEntry, params[0].gpr());
});
resumeAddress = Pointer(patch);
}
define(value, callOperation<Boxed>(value, RuntimeOperation::TakeGeneratorLeftInPlace, { holder, words, resumeAddress, word32(value->leavesAtOnce()), word32(value->isHeldByIteration()) }, { .isOnRarePath = true }));
}

void SavedFrameEmitter::generateIsCallDelegated(const ValueContext& value)
Expand Down
3 changes: 3 additions & 0 deletions Source/JavaScriptCore/aot/codegen/AOTSavedFrameEmitter.h
Original file line number Diff line number Diff line change
Expand Up @@ -46,8 +46,11 @@ class SavedFrameEmitter final : public OperationEmitter {
void branchUnlessUnmodifiedAsyncGenerator(CellPointer generator, LBasicBlock otherwise);

void generateNewHeapWords(const ValueContext&);
void generateNewSuspendedIteration(const ValueContext&);
void generateNewSuspendedEnumeration(const ValueContext&);
void generateGetHeapFrameWord(const ValueContext&);
void generatePutHeapFrameWord(const ValueContext&);
void generatePutHeapFrameScope(const ValueContext&);

bool layOutHeapFrame();
bool standsBehindFirstYield(BlockID block) const { return m_blocksBehindFirstYield.get(block.index()) || (block == m_blockOfFirstYield && m_hasPassedFirstYield); }
Expand Down
Loading
Loading