bytecode-array-accessor.h 4.15 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12
// 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_ACCESSOR_H_
#define V8_INTERPRETER_BYTECODE_ARRAY_ACCESSOR_H_

#include "src/globals.h"
#include "src/handles.h"
#include "src/interpreter/bytecode-register.h"
#include "src/interpreter/bytecodes.h"
#include "src/objects.h"
13
#include "src/objects/smi.h"
14 15 16 17
#include "src/runtime/runtime.h"

namespace v8 {
namespace internal {
18 19 20

class BytecodeArray;

21 22
namespace interpreter {

23 24
class BytecodeArrayAccessor;

25
struct V8_EXPORT_PRIVATE JumpTableTargetOffset {
26 27 28 29
  int case_value;
  int target_offset;
};

30
class V8_EXPORT_PRIVATE JumpTableTargetOffsets final {
31 32
 public:
  // Minimal iterator implementation for use in ranged-for.
33
  class V8_EXPORT_PRIVATE iterator final {
34 35 36 37 38 39 40 41 42 43 44 45
   public:
    iterator(int case_value, int table_offset, int table_end,
             const BytecodeArrayAccessor* accessor);

    JumpTableTargetOffset operator*();
    iterator& operator++();
    bool operator!=(const iterator& other);

   private:
    void UpdateAndAdvanceToValid();

    const BytecodeArrayAccessor* accessor_;
46
    Smi current_;
47 48 49 50 51 52 53 54 55 56 57
    int index_;
    int table_offset_;
    int table_end_;
  };

  JumpTableTargetOffsets(const BytecodeArrayAccessor* accessor, int table_start,
                         int table_size, int case_value_base);

  iterator begin() const;
  iterator end() const;

58 59
  int size() const;

60 61 62 63 64 65 66
 private:
  const BytecodeArrayAccessor* accessor_;
  int table_start_;
  int table_size_;
  int case_value_base_;
};

67 68 69 70 71 72 73
class V8_EXPORT_PRIVATE BytecodeArrayAccessor {
 public:
  BytecodeArrayAccessor(Handle<BytecodeArray> bytecode_array,
                        int initial_offset);

  void SetOffset(int offset);

74 75
  void ApplyDebugBreak();

76 77 78 79 80 81 82 83 84 85 86 87 88
  Bytecode current_bytecode() const;
  int current_bytecode_size() const;
  int current_offset() const { return bytecode_offset_; }
  OperandScale current_operand_scale() const { return operand_scale_; }
  int current_prefix_offset() const { return prefix_offset_; }
  const Handle<BytecodeArray>& bytecode_array() const {
    return bytecode_array_;
  }

  uint32_t GetFlagOperand(int operand_index) const;
  uint32_t GetUnsignedImmediateOperand(int operand_index) const;
  int32_t GetImmediateOperand(int operand_index) const;
  uint32_t GetIndexOperand(int operand_index) const;
89
  FeedbackSlot GetSlotOperand(int operand_index) const;
90 91 92 93 94
  uint32_t GetRegisterCountOperand(int operand_index) const;
  Register GetRegisterOperand(int operand_index) const;
  int GetRegisterOperandRange(int operand_index) const;
  Runtime::FunctionId GetRuntimeIdOperand(int operand_index) const;
  Runtime::FunctionId GetIntrinsicIdOperand(int operand_index) const;
95
  uint32_t GetNativeContextIndexOperand(int operand_index) const;
96 97
  Object GetConstantAtIndex(int offset) const;
  Object GetConstantForIndexOperand(int operand_index) const;
98

99 100 101
  // 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.
102
  int GetJumpTargetOffset() const;
103 104 105 106 107 108 109 110
  // 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;
111

112 113
  bool OffsetWithinBytecode(int offset) const;

114 115
  std::ostream& PrintTo(std::ostream& os) const;

116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
 private:
  bool OffsetInBounds() const;

  uint32_t GetUnsignedOperand(int operand_index,
                              OperandType operand_type) const;
  int32_t GetSignedOperand(int operand_index, OperandType operand_type) const;

  void UpdateOperandScale();

  Handle<BytecodeArray> bytecode_array_;
  int bytecode_offset_;
  OperandScale operand_scale_;
  int prefix_offset_;

  DISALLOW_COPY_AND_ASSIGN(BytecodeArrayAccessor);
};

}  // namespace interpreter
}  // namespace internal
}  // namespace v8

137
#endif  // V8_INTERPRETER_BYTECODE_ARRAY_ACCESSOR_H_