{

unsigned frameSize = 0;

for (StackSlot* slot : collection)

frameSize = std::max(frameSize, static_cast<unsigned>(-slot->offsetFromFP()));

code.setFrameSize(WTF::roundUpToMultipleOf<stackAlignmentBytes()>(frameSize) + stackAdjustmentForAlignment());

{

dataLogLnIf(AirStackAllocationInternal::verbose, "Attempting to assign ", pointerDump(slot), " with interference ", pointerListDump(otherSlots));

// Start candidate at the top of the frame and push it down past any overlapping slot.

intptr_t offsetFromFP = -static_cast<intptr_t>(slot->byteSize());

offsetFromFP = -WTF::roundUpToMultipleOf(slot->alignment(), -offsetFromFP);

intptr_t prevOffset = 0;

for (StackSlot* otherSlot : otherSlots) {

ASSERT(otherSlot->offsetFromFP() < 0);

ASSERT_UNUSED(prevOffset, otherSlot->offsetFromFP() <= prevOffset);

prevOffset = otherSlot->offsetFromFP();

bool overlap = WTF::rangesOverlap(

offsetFromFP,

offsetFromFP + static_cast<intptr_t>(slot->byteSize()),

otherSlot->offsetFromFP(),

otherSlot->offsetFromFP() + static_cast<intptr_t>(otherSlot->byteSize()));

if (overlap) {

offsetFromFP = otherSlot->offsetFromFP() - static_cast<intptr_t>(slot->byteSize());

offsetFromFP = -WTF::roundUpToMultipleOf(slot->alignment(), -offsetFromFP);

}

}

dataLogLnIf(AirStackAllocationInternal::verbose, "Assigned ", pointerDump(slot), " to ", offsetFromFP);

slot->setOffsetFromFP(offsetFromFP);

{

// Allocate all of the escaped slots in order. This is kind of a crazy algorithm to allow for

// the possibility of stack slots being assigned frame offsets before we even get here.

RELEASE_ASSERT(code.frameSize() == stackAdjustmentForAlignment());

Vector<StackSlot*> assignedEscapedStackSlots;

Vector<StackSlot*> escapedStackSlotsWorklist;

for (StackSlot* slot : code.stackSlots()) {

if (slot->isLocked()) {

if (slot->offsetFromFP())

assignedEscapedStackSlots.append(slot);

else

escapedStackSlotsWorklist.append(slot);

} else {

// It would be super strange to have an unlocked stack slot that has an offset already.

ASSERT(!slot->offsetFromFP());

}

}

std::ranges::sort(assignedEscapedStackSlots, std::ranges::greater { }, &StackSlot::offsetFromFP);

// This is a fairly expensive loop, but it's OK because we'll usually only have a handful of

// escaped stack slots.

while (!escapedStackSlotsWorklist.isEmpty()) {

StackSlot* slot = escapedStackSlotsWorklist.takeLast();

assign(slot, assignedEscapedStackSlots);

auto it = std::ranges::upper_bound(assignedEscapedStackSlots, slot->offsetFromFP(), std::ranges::greater { }, &StackSlot::offsetFromFP);

assignedEscapedStackSlots.insert(it - assignedEscapedStackSlots.begin(), slot);

}

return assignedEscapedStackSlots;

{

updateFrameSizeBasedOnStackSlotsImpl(

code, allocateAndGetEscapedStackSlotsWithoutChangingFrameSize(code));