#pragma once
#include "BytecodeBasicBlock.h"
#include "BytecodeDumper.h"
#include <wtf/IndexedContainerIterator.h>
#include <wtf/IteratorRange.h>
#include <wtf/Vector.h>
namespace JSC {
class BytecodeBasicBlock;
class BytecodeGraph {
WTF_MAKE_FAST_ALLOCATED;
WTF_MAKE_NONCOPYABLE(BytecodeGraph);
public:
using BasicBlocksVector = BytecodeBasicBlock::BasicBlockVector;
typedef WTF::IndexedContainerIterator<BytecodeGraph> iterator;
template <typename CodeBlockType>
inline BytecodeGraph(CodeBlockType*, const InstructionStream&);
WTF::IteratorRange<BasicBlocksVector::reverse_iterator> basicBlocksInReverseOrder()
{
return WTF::makeIteratorRange(m_basicBlocks.rbegin(), m_basicBlocks.rend());
}
static bool blockContainsBytecodeOffset(const BytecodeBasicBlock& block, InstructionStream::Offset bytecodeOffset)
{
unsigned leaderOffset = block.leaderOffset();
return bytecodeOffset >= leaderOffset && bytecodeOffset < leaderOffset + block.totalLength();
}
BytecodeBasicBlock* findBasicBlockForBytecodeOffset(InstructionStream::Offset bytecodeOffset)
{
BytecodeBasicBlock* basicBlock = approximateBinarySearch<BytecodeBasicBlock, unsigned>(m_basicBlocks, m_basicBlocks.size(), bytecodeOffset, [] (BytecodeBasicBlock* basicBlock) { return basicBlock->leaderOffset(); });
if (blockContainsBytecodeOffset(*basicBlock, bytecodeOffset))
return basicBlock;
if (bytecodeOffset < basicBlock->leaderOffset()) {
ASSERT(basicBlock - 1 >= m_basicBlocks.data());
ASSERT(blockContainsBytecodeOffset(basicBlock[-1], bytecodeOffset));
return &basicBlock[-1];
}
ASSERT(&basicBlock[1] <= &m_basicBlocks.last());
ASSERT(blockContainsBytecodeOffset(basicBlock[1], bytecodeOffset));
return &basicBlock[1];
}
BytecodeBasicBlock* findBasicBlockWithLeaderOffset(InstructionStream::Offset leaderOffset)
{
return tryBinarySearch<BytecodeBasicBlock, unsigned>(m_basicBlocks, m_basicBlocks.size(), leaderOffset, [] (BytecodeBasicBlock* basicBlock) { return basicBlock->leaderOffset(); });
}
unsigned size() const { return m_basicBlocks.size(); }
BytecodeBasicBlock& at(unsigned index) const { return const_cast<BytecodeGraph*>(this)->m_basicBlocks[index]; }
BytecodeBasicBlock& operator[](unsigned index) const { return at(index); }
iterator begin() { return iterator(*this, 0); }
iterator end() { return iterator(*this, size()); }
BytecodeBasicBlock& first() { return at(0); }
BytecodeBasicBlock& last() { return at(size() - 1); }
template <typename CodeBlockType>
void dump(CodeBlockType* codeBlock, const InstructionStream& instructions, Optional<Vector<Operands<SpeculatedType>>> speculationAtHead, PrintStream& printer = WTF::dataFile())
{
CodeBlockBytecodeDumper<CodeBlockType>::dumpGraph(codeBlock, instructions, *this, speculationAtHead, printer);
}
private:
BasicBlocksVector m_basicBlocks;
};
template<typename CodeBlockType>
BytecodeGraph::BytecodeGraph(CodeBlockType* codeBlock, const InstructionStream& instructions)
: m_basicBlocks(BytecodeBasicBlock::compute(codeBlock, instructions))
{
ASSERT(m_basicBlocks.size());
}
}