bytecode-array-iterator.cc | Explore in Territory

// Copyright 2015 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.

#include "src/interpreter/bytecode-array-iterator.h"

#include "src/interpreter/bytecode-decoder.h"
#include "src/interpreter/interpreter-intrinsics.h"
#include "src/objects/feedback-vector.h"
#include "src/objects/objects-inl.h"

namespace v8 {
namespace internal {
namespace interpreter {

BytecodeArrayIterator::BytecodeArrayIterator(
    Handle<BytecodeArray> bytecode_array, int initial_offset)
    : … { … }

BytecodeArrayIterator::BytecodeArrayIterator(
    Handle<BytecodeArray> bytecode_array, int initial_offset,
    DisallowGarbageCollection& no_gc)
    : … { … }

BytecodeArrayIterator::~BytecodeArrayIterator() { … }

void BytecodeArrayIterator::SetOffset(int offset) { … }

// static
bool BytecodeArrayIterator::IsValidOffset(Handle<BytecodeArray> bytecode_array,
                                          int offset) { … }

void BytecodeArrayIterator::ApplyDebugBreak() { … }

uint32_t BytecodeArrayIterator::GetUnsignedOperand(
    int operand_index, OperandType operand_type) const { … }

int32_t BytecodeArrayIterator::GetSignedOperand(
    int operand_index, OperandType operand_type) const { … }

uint32_t BytecodeArrayIterator::GetFlag8Operand(int operand_index) const { … }

uint32_t BytecodeArrayIterator::GetFlag16Operand(int operand_index) const { … }

uint32_t BytecodeArrayIterator::GetUnsignedImmediateOperand(
    int operand_index) const { … }

int32_t BytecodeArrayIterator::GetImmediateOperand(int operand_index) const { … }

uint32_t BytecodeArrayIterator::GetRegisterCountOperand(
    int operand_index) const { … }

uint32_t BytecodeArrayIterator::GetIndexOperand(int operand_index) const { … }

FeedbackSlot BytecodeArrayIterator::GetSlotOperand(int operand_index) const { … }

Register BytecodeArrayIterator::GetParameter(int parameter_index) const { … }

Register BytecodeArrayIterator::GetRegisterOperand(int operand_index) const { … }

Register BytecodeArrayIterator::GetStarTargetRegister() const { … }

std::pair<Register, Register> BytecodeArrayIterator::GetRegisterPairOperand(
    int operand_index) const { … }

RegisterList BytecodeArrayIterator::GetRegisterListOperand(
    int operand_index) const { … }

int BytecodeArrayIterator::GetRegisterOperandRange(int operand_index) const { … }

Runtime::FunctionId BytecodeArrayIterator::GetRuntimeIdOperand(
    int operand_index) const { … }

uint32_t BytecodeArrayIterator::GetNativeContextIndexOperand(
    int operand_index) const { … }

Runtime::FunctionId BytecodeArrayIterator::GetIntrinsicIdOperand(
    int operand_index) const { … }

template <typename IsolateT>
Handle<Object> BytecodeArrayIterator::GetConstantAtIndex(
    int index, IsolateT* isolate) const { … }

bool BytecodeArrayIterator::IsConstantAtIndexSmi(int index) const { … }

Tagged<Smi> BytecodeArrayIterator::GetConstantAtIndexAsSmi(int index) const { … }

template <typename IsolateT>
Handle<Object> BytecodeArrayIterator::GetConstantForIndexOperand(
    int operand_index, IsolateT* isolate) const { … }

template EXPORT_TEMPLATE_DEFINE(…)
    Handle<Object> BytecodeArrayIterator::GetConstantForIndexOperand(
        int operand_index, Isolate* isolate) const;
template Handle<Object> BytecodeArrayIterator::GetConstantForIndexOperand(
    int operand_index, LocalIsolate* isolate) const;

int BytecodeArrayIterator::GetRelativeJumpTargetOffset() const { … }

int BytecodeArrayIterator::GetJumpTargetOffset() const { … }

JumpTableTargetOffsets BytecodeArrayIterator::GetJumpTableTargetOffsets()
    const { … }

int BytecodeArrayIterator::GetAbsoluteOffset(int relative_offset) const { … }

std::ostream& BytecodeArrayIterator::PrintTo(std::ostream& os) const { … }

void BytecodeArrayIterator::UpdatePointers() { … }

JumpTableTargetOffsets::JumpTableTargetOffsets(
    const BytecodeArrayIterator* iterator, int table_start, int table_size,
    int case_value_base)
    : … { … }

JumpTableTargetOffsets::iterator JumpTableTargetOffsets::begin() const { … }
JumpTableTargetOffsets::iterator JumpTableTargetOffsets::end() const { … }
int JumpTableTargetOffsets::size() const { … }

JumpTableTargetOffsets::iterator::iterator(
    int case_value, int table_offset, int table_end,
    const BytecodeArrayIterator* iterator)
    : … { … }

JumpTableTargetOffset JumpTableTargetOffsets::iterator::operator*() { … }

JumpTableTargetOffsets::iterator&
JumpTableTargetOffsets::iterator::operator++() { … }

bool JumpTableTargetOffsets::iterator::operator!=(
    const JumpTableTargetOffsets::iterator& other) { … }

void JumpTableTargetOffsets::iterator::UpdateAndAdvanceToValid() { … }

}  // namespace interpreter
}  // namespace internal
}  // namespace v8
chromium/v8/src/interpreter/bytecode-array-iterator.cc
