#include "config.h"

#include "B3BlockInsertionSet.h"

#if ENABLE(B3_JIT)

#include "B3InsertionSet.h"

#include "B3ProcedureInlines.h"

#include "B3ValueInlines.h"

namespace JSC { namespace B3 {

BlockInsertionSet::BlockInsertionSet(Procedure &proc)

}

BlockInsertionSet::~BlockInsertionSet() = default;

BasicBlock* BlockInsertionSet::splitForward(

BasicBlock* block, unsigned& valueIndex, InsertionSet* insertionSet, double frequency)

{

Value* value = block->at(valueIndex);

// Create a new block that will go just before 'block', and make it contain everything prior

// to 'valueIndex'.

BasicBlock* result = insertBefore(block, frequency);

result->m_values.resize(valueIndex + 1);

for (unsigned i = valueIndex; i--;)

result->m_values[i] = block->m_values[i];

// Make the new block jump to 'block'.

result->m_values[valueIndex] = m_proc.add<Value>(Jump, value->origin());

result->setSuccessors(FrequentedBlock(block));

// If we had inserted things into 'block' before this, execute those insertions now.

if (insertionSet)

insertionSet->execute(result);

// Remove everything prior to 'valueIndex' from 'block', since those things are now in the

// new block.

block->m_values.removeAt(0, valueIndex);

// This is being used in a forward loop over 'block'. Update the index of the loop so that

// it can continue to the next block.

valueIndex = 0;

// Fixup the predecessors of 'block'. They now must jump to the new block.

result->predecessors() = WTF::move(block->predecessors());

block->addPredecessor(result);

for (BasicBlock* predecessor : result->predecessors())

predecessor->replaceSuccessor(block, result);

return result;

}

} } // namespace JSC::B3

#endif // ENABLE(B3_JIT)