// Copyright 2016 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_INTERPRETER_BYTECODE_ARRAY_ITERATOR_H_
#define V8_INTERPRETER_BYTECODE_ARRAY_ITERATOR_H_
#include <memory>
#include "include/v8-callbacks.h"
#include "include/v8config.h"
#include "src/common/globals.h"
#include "src/handles/handles.h"
#include "src/interpreter/bytecode-register.h"
#include "src/interpreter/bytecodes.h"
#include "src/objects/objects.h"
#include "src/objects/smi.h"
#include "src/objects/type-hints.h"
#include "src/runtime/runtime.h"
namespace v8 {
namespace internal {
class BytecodeArray;
enum class AbortReason : uint8_t;
namespace interpreter {
class BytecodeArrayIterator;
struct V8_EXPORT_PRIVATE JumpTableTargetOffset {
int case_value;
int target_offset;
};
class V8_EXPORT_PRIVATE JumpTableTargetOffsets final {
public:
// Minimal iterator implementation for use in ranged-for.
class V8_EXPORT_PRIVATE iterator final {
public:
iterator(int case_value, int table_offset, int table_end,
const BytecodeArrayIterator* iterator);
JumpTableTargetOffset operator*();
iterator& operator++();
bool operator!=(const iterator& other);
private:
void UpdateAndAdvanceToValid();
const BytecodeArrayIterator* iterator_;
Tagged<Smi> current_;
int index_;
int table_offset_;
int table_end_;
};
JumpTableTargetOffsets(const BytecodeArrayIterator* iterator, int table_start,
int table_size, int case_value_base);
iterator begin() const;
iterator end() const;
int size() const;
private:
const BytecodeArrayIterator* iterator_;
int table_start_;
int table_size_;
int case_value_base_;
};
template <typename Feedback>
struct EmbeddedFeedbackHintTraits;
template <>
struct EmbeddedFeedbackHintTraits<CompareOperationFeedback> {
using Hint = CompareOperationHint;
static Hint FromFeedback(uint32_t feedback_value);
static bool IsWithEmbeddedFeedbackOp(Bytecode bc) {
return Bytecodes::IsCompareWithEmbeddedFeedback(bc);
}
};
template <>
struct EmbeddedFeedbackHintTraits<BinaryOperationFeedback> {
using Hint = BinaryOperationHint;
static Hint FromFeedback(uint32_t feedback_value);
static bool IsWithEmbeddedFeedbackOp(Bytecode bc) {
return Bytecodes::IsBinaryOpWithEmbeddedFeedback(bc) ||
Bytecodes::IsUnaryOpWithEmbeddedFeedback(bc);
}
};
class V8_EXPORT_PRIVATE BytecodeArrayIterator {
public:
explicit BytecodeArrayIterator(Handle<BytecodeArray> bytecode_array,
int initial_offset = 0);
BytecodeArrayIterator(Handle<BytecodeArray> bytecode_array,
int initial_offset,
DisallowGarbageCollection& no_gc V8_LIFETIME_BOUND);
~BytecodeArrayIterator();
BytecodeArrayIterator(const BytecodeArrayIterator&) = delete;
BytecodeArrayIterator& operator=(const BytecodeArrayIterator&) = delete;
inline void Advance() {
cursor_ += current_bytecode_size_without_prefix();
UpdateCurrentBytecode();
}
// Prefer AdvanceTo over SetOffset if the new offset is greater than the
// current offset as it is more efficient.
void AdvanceTo(int offset);
void SetOffset(int offset);
void Reset();
// Whether the given offset is reachable in this bytecode array.
static bool IsValidOffset(Handle<BytecodeArray> bytecode_array, int offset);
static bool IsValidOSREntryOffset(Handle<BytecodeArray> bytecode_array,
int offset);
bool CurrentBytecodeIsValidOSREntry() const;
void ApplyDebugBreak();
inline Bytecode current_bytecode() const { return current_bytecode_; }
int current_bytecode_size() const {
return prefix_size_ + current_bytecode_size_without_prefix();
}
int current_bytecode_size_without_prefix() const {
return Bytecodes::Size(current_bytecode_, current_operand_scale());
}
int current_offset() const {
DCHECK(!done());
return static_cast<int>(cursor_ - start_ - prefix_size_);
}
int current_operand_offset(int operand_index) const {
return Bytecodes::GetOperandOffset(current_bytecode(), operand_index,
current_operand_scale());
}
uint8_t* current_address() const { return cursor_ - prefix_size_; }
int next_offset() const { return current_offset() + current_bytecode_size(); }
Bytecode next_bytecode() const {
uint8_t* next_cursor = cursor_ + current_bytecode_size_without_prefix();
if (next_cursor == end_) return Bytecode::kIllegal;
Bytecode next_bytecode = Bytecodes::FromByte(*next_cursor);
if (Bytecodes::IsPrefixScalingBytecode(next_bytecode)) {
next_bytecode = Bytecodes::FromByte(*(next_cursor + 1));
}
return next_bytecode;
}
OperandScale current_operand_scale() const { return operand_scale_; }
DirectHandle<BytecodeArray> bytecode_array() const { return bytecode_array_; }
uint32_t GetFlag8Operand(int operand_index) const;
uint32_t GetFlag16Operand(int operand_index) const;
uint32_t GetUnsignedImmediateOperand(int operand_index) const;
int32_t GetImmediateOperand(int operand_index) const;
uint32_t GetConstantPoolIndexOperand(int operand_index) const;
uint32_t GetFeedbackSlotOperand(int operand_index) const;
uint32_t GetContextSlotOperand(int operand_index) const;
uint32_t GetCoverageSlotOperand(int operand_index) const;
FeedbackSlot GetSlotOperand(int operand_index) const;
Register GetParameter(int parameter_index) const;
uint32_t GetRegisterCountOperand(int operand_index) const;
Register GetRegisterOperand(int operand_index) const;
Register GetStarTargetRegister() const;
std::pair<Register, Register> GetRegisterPairOperand(int operand_index) const;
RegisterList GetRegisterListOperand(int operand_index) const;
uint32_t GetRegisterOperandRange(int operand_index) const;
Runtime::FunctionId GetRuntimeIdOperand(int operand_index) const;
Runtime::FunctionId GetIntrinsicIdOperand(int operand_index) const;
uint32_t GetNativeContextIndexOperand(int operand_index) const;
AbortReason GetAbortReasonOperand(int operand_index) const;
uint8_t GetEmbeddedFeedback(int operand_index) const;
Tagged<Object> GetConstantAtIndex(int offset) const;
Handle<Object> GetConstantAtIndex(int offset, Isolate* isolate) const;
Handle<Object> GetConstantAtIndex(int offset, LocalIsolate* isolate) const;
Tagged<Smi> GetConstantAtIndexAsSmi(int offset) const;
Handle<Object> GetConstantForOperand(int operand_index,
Isolate* isolate) const;
Handle<Object> GetConstantForOperand(int operand_index,
LocalIsolate* isolate) const;
// Returns the relative offset of the branch target at the current bytecode.
// It is an error to call this method if the bytecode is not for a jump or
// conditional jump. Returns a negative offset for backward jumps.
int GetRelativeJumpTargetOffset() const;
// Returns the absolute offset of the branch target at the current bytecode.
// It is an error to call this method if the bytecode is not for a jump or
// conditional jump.
int GetJumpTargetOffset() const;
// Returns an iterator over the absolute offsets of the targets of the current
// switch bytecode's jump table. It is an error to call this method if the
// bytecode is not a switch.
JumpTableTargetOffsets GetJumpTableTargetOffsets() const;
// Returns the absolute offset of the bytecode at the given relative offset
// from the current bytecode.
int GetAbsoluteOffset(int relative_offset) const;
std::ostream& PrintCurrentBytecodeTo(std::ostream& os) const;
static void UpdatePointersCallback(void* iterator) {
reinterpret_cast<BytecodeArrayIterator*>(iterator)->UpdatePointers();
}
void UpdatePointers();
template <typename Feedback>
typename EmbeddedFeedbackHintTraits<Feedback>::Hint
GetEmbeddedOperationHint();
CompareOperationHint GetEmbeddedCompareOperationHint() {
return GetEmbeddedOperationHint<CompareOperationFeedback>();
}
int GetEmbeddedFeedbackOffset(int operand_index) const;
inline bool done() const { return cursor_ == nullptr; }
bool operator==(const BytecodeArrayIterator& other) const {
return cursor_ == other.cursor_;
}
bool operator!=(const BytecodeArrayIterator& other) const {
return cursor_ != other.cursor_;
}
protected:
void SetOffsetUnchecked(int offset);
private:
uint32_t GetUnsignedOperand(int operand_index,
OperandType operand_type) const;
int32_t GetSignedOperand(int operand_index, OperandType operand_type) const;
inline void UpdateCurrentBytecode() {
if (cursor_ >= end_) {
cursor_ = nullptr;
prefix_size_ = 0;
current_bytecode_ = Bytecode::kIllegal;
DCHECK(done());
return;
}
DCHECK(!done());
current_bytecode_ = Bytecodes::FromByte(*cursor_);
if (Bytecodes::IsPrefixScalingBytecode(current_bytecode_)) {
operand_scale_ =
Bytecodes::PrefixBytecodeToOperandScale(current_bytecode_);
++cursor_;
current_bytecode_ = Bytecodes::FromByte(*cursor_);
DCHECK(!Bytecodes::IsPrefixScalingBytecode(current_bytecode_));
prefix_size_ = 1;
} else {
operand_scale_ = OperandScale::kSingle;
prefix_size_ = 0;
}
}
Handle<BytecodeArray> bytecode_array_;
uint8_t* start_;
uint8_t* end_;
// The cursor always points to the active bytecode. If there's a prefix, the
// prefix is at (cursor - 1).
uint8_t* cursor_;
Bytecode current_bytecode_;
OperandScale operand_scale_;
int prefix_size_;
LocalHeap* const local_heap_;
};
} // namespace interpreter
} // namespace internal
} // namespace v8
#endif // V8_INTERPRETER_BYTECODE_ARRAY_ITERATOR_H_