handler-table.cc 9.17 KB
Newer Older
1 2 3 4
// Copyright 2018 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.

5
#include "src/codegen/handler-table.h"
6

7
#include <algorithm>
8 9
#include <iomanip>

10
#include "src/base/iterator.h"
11
#include "src/codegen/assembler-inl.h"
12
#include "src/objects/code-inl.h"
13
#include "src/objects/objects-inl.h"
14
#include "src/wasm/wasm-code-manager.h"
15 16 17 18

namespace v8 {
namespace internal {

19
HandlerTable::HandlerTable(Code code)
20 21 22 23 24 25
    : HandlerTable(code.HandlerTableAddress(), code.handler_table_size(),
                   kReturnAddressBasedEncoding) {}

HandlerTable::HandlerTable(const wasm::WasmCode* code)
    : HandlerTable(code->handler_table(), code->handler_table_size(),
                   kReturnAddressBasedEncoding) {}
26

27
HandlerTable::HandlerTable(BytecodeArray bytecode_array)
28
    : HandlerTable(bytecode_array.handler_table()) {}
29

30
HandlerTable::HandlerTable(ByteArray byte_array)
31 32
    : HandlerTable(reinterpret_cast<Address>(byte_array.GetDataStartAddress()),
                   byte_array.length(), kRangeBasedEncoding) {}
33

34 35 36
HandlerTable::HandlerTable(Address handler_table, int handler_table_size,
                           EncodingMode encoding_mode)
    : number_of_entries_(handler_table_size / EntrySizeFromMode(encoding_mode) /
37
                         sizeof(int32_t)),
38
#ifdef DEBUG
39
      mode_(encoding_mode),
40
#endif
41
      raw_encoded_data_(handler_table) {
42
  // Check padding.
43
  static_assert(4 < kReturnEntrySize * sizeof(int32_t), "allowed padding");
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
  // For return address encoding, maximum padding is 4; otherwise, there should
  // be no padding.
  DCHECK_GE(kReturnAddressBasedEncoding == encoding_mode ? 4 : 0,
            handler_table_size %
                (EntrySizeFromMode(encoding_mode) * sizeof(int32_t)));
}

// static
int HandlerTable::EntrySizeFromMode(EncodingMode mode) {
  switch (mode) {
    case kReturnAddressBasedEncoding:
      return kReturnEntrySize;
    case kRangeBasedEncoding:
      return kRangeEntrySize;
  }
  UNREACHABLE();
60 61 62 63 64 65
}

int HandlerTable::GetRangeStart(int index) const {
  DCHECK_EQ(kRangeBasedEncoding, mode_);
  DCHECK_LT(index, NumberOfRangeEntries());
  int offset = index * kRangeEntrySize + kRangeStartIndex;
66
  return Memory<int32_t>(raw_encoded_data_ + offset * sizeof(int32_t));
67 68 69 70 71 72
}

int HandlerTable::GetRangeEnd(int index) const {
  DCHECK_EQ(kRangeBasedEncoding, mode_);
  DCHECK_LT(index, NumberOfRangeEntries());
  int offset = index * kRangeEntrySize + kRangeEndIndex;
73
  return Memory<int32_t>(raw_encoded_data_ + offset * sizeof(int32_t));
74 75 76 77 78 79 80
}

int HandlerTable::GetRangeHandler(int index) const {
  DCHECK_EQ(kRangeBasedEncoding, mode_);
  DCHECK_LT(index, NumberOfRangeEntries());
  int offset = index * kRangeEntrySize + kRangeHandlerIndex;
  return HandlerOffsetField::decode(
81
      Memory<int32_t>(raw_encoded_data_ + offset * sizeof(int32_t)));
82 83 84 85 86 87
}

int HandlerTable::GetRangeData(int index) const {
  DCHECK_EQ(kRangeBasedEncoding, mode_);
  DCHECK_LT(index, NumberOfRangeEntries());
  int offset = index * kRangeEntrySize + kRangeDataIndex;
88
  return Memory<int32_t>(raw_encoded_data_ + offset * sizeof(int32_t));
89 90 91 92 93 94 95 96
}

HandlerTable::CatchPrediction HandlerTable::GetRangePrediction(
    int index) const {
  DCHECK_EQ(kRangeBasedEncoding, mode_);
  DCHECK_LT(index, NumberOfRangeEntries());
  int offset = index * kRangeEntrySize + kRangeHandlerIndex;
  return HandlerPredictionField::decode(
97
      Memory<int32_t>(raw_encoded_data_ + offset * sizeof(int32_t)));
98 99 100 101 102 103
}

int HandlerTable::GetReturnOffset(int index) const {
  DCHECK_EQ(kReturnAddressBasedEncoding, mode_);
  DCHECK_LT(index, NumberOfReturnEntries());
  int offset = index * kReturnEntrySize + kReturnOffsetIndex;
104
  return Memory<int32_t>(raw_encoded_data_ + offset * sizeof(int32_t));
105 106 107 108 109 110 111
}

int HandlerTable::GetReturnHandler(int index) const {
  DCHECK_EQ(kReturnAddressBasedEncoding, mode_);
  DCHECK_LT(index, NumberOfReturnEntries());
  int offset = index * kReturnEntrySize + kReturnHandlerIndex;
  return HandlerOffsetField::decode(
112
      Memory<int32_t>(raw_encoded_data_ + offset * sizeof(int32_t)));
113 114 115 116
}

void HandlerTable::SetRangeStart(int index, int value) {
  int offset = index * kRangeEntrySize + kRangeStartIndex;
117
  Memory<int32_t>(raw_encoded_data_ + offset * sizeof(int32_t)) = value;
118 119 120 121
}

void HandlerTable::SetRangeEnd(int index, int value) {
  int offset = index * kRangeEntrySize + kRangeEndIndex;
122
  Memory<int32_t>(raw_encoded_data_ + offset * sizeof(int32_t)) = value;
123 124 125 126 127 128 129
}

void HandlerTable::SetRangeHandler(int index, int handler_offset,
                                   CatchPrediction prediction) {
  int value = HandlerOffsetField::encode(handler_offset) |
              HandlerPredictionField::encode(prediction);
  int offset = index * kRangeEntrySize + kRangeHandlerIndex;
130
  Memory<int32_t>(raw_encoded_data_ + offset * sizeof(int32_t)) = value;
131 132 133 134
}

void HandlerTable::SetRangeData(int index, int value) {
  int offset = index * kRangeEntrySize + kRangeDataIndex;
135
  Memory<int32_t>(raw_encoded_data_ + offset * sizeof(int32_t)) = value;
136 137 138 139 140 141 142 143
}

// static
int HandlerTable::LengthForRange(int entries) {
  return entries * kRangeEntrySize * sizeof(int32_t);
}

// static
144
int HandlerTable::EmitReturnTableStart(Assembler* masm) {
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
  masm->DataAlign(sizeof(int32_t));  // Make sure entries are aligned.
  masm->RecordComment(";;; Exception handler table.");
  int table_start = masm->pc_offset();
  return table_start;
}

// static
void HandlerTable::EmitReturnEntry(Assembler* masm, int offset, int handler) {
  masm->dd(offset);
  masm->dd(HandlerOffsetField::encode(handler));
}

int HandlerTable::NumberOfRangeEntries() const {
  DCHECK_EQ(kRangeBasedEncoding, mode_);
  return number_of_entries_;
}

int HandlerTable::NumberOfReturnEntries() const {
  DCHECK_EQ(kReturnAddressBasedEncoding, mode_);
  return number_of_entries_;
}

int HandlerTable::LookupRange(int pc_offset, int* data_out,
                              CatchPrediction* prediction_out) {
  int innermost_handler = -1;
#ifdef DEBUG
  // Assuming that ranges are well nested, we don't need to track the innermost
  // offsets. This is just to verify that the table is actually well nested.
  int innermost_start = std::numeric_limits<int>::min();
  int innermost_end = std::numeric_limits<int>::max();
#endif
  for (int i = 0; i < NumberOfRangeEntries(); ++i) {
    int start_offset = GetRangeStart(i);
    int end_offset = GetRangeEnd(i);
    int handler_offset = GetRangeHandler(i);
    int handler_data = GetRangeData(i);
    CatchPrediction prediction = GetRangePrediction(i);
    if (pc_offset >= start_offset && pc_offset < end_offset) {
      DCHECK_GE(start_offset, innermost_start);
      DCHECK_LT(end_offset, innermost_end);
      innermost_handler = handler_offset;
#ifdef DEBUG
      innermost_start = start_offset;
      innermost_end = end_offset;
#endif
      if (data_out) *data_out = handler_data;
      if (prediction_out) *prediction_out = prediction;
    }
  }
  return innermost_handler;
}

int HandlerTable::LookupReturn(int pc_offset) {
198 199 200 201 202 203 204 205
  // We only implement the methods needed by the standard libraries we care
  // about. This is not technically a full random access iterator by the spec.
  struct Iterator : base::iterator<std::random_access_iterator_tag, int> {
    Iterator(HandlerTable* tbl, int idx) : table(tbl), index(idx) {}
    value_type operator*() const { return table->GetReturnOffset(index); }
    bool operator!=(const Iterator& other) const { return !(*this == other); }
    bool operator==(const Iterator& other) const {
      return index == other.index;
206
    }
207 208 209 210
    Iterator& operator++() {
      index++;
      return *this;
    }
211 212 213 214
    Iterator& operator--() {
      index--;
      return *this;
    }
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
    Iterator& operator+=(difference_type offset) {
      index += offset;
      return *this;
    }
    difference_type operator-(const Iterator& other) const {
      return index - other.index;
    }
    HandlerTable* table;
    int index;
  };
  Iterator begin{this, 0}, end{this, NumberOfReturnEntries()};
  SLOW_DCHECK(std::is_sorted(begin, end));  // Must be sorted.
  Iterator result = std::lower_bound(begin, end, pc_offset);
  bool exact_match = result != end && *result == pc_offset;
  return exact_match ? GetReturnHandler(result.index) : -1;
230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
}

#ifdef ENABLE_DISASSEMBLER

void HandlerTable::HandlerTableRangePrint(std::ostream& os) {
  os << "   from   to       hdlr (prediction,   data)\n";
  for (int i = 0; i < NumberOfRangeEntries(); ++i) {
    int pc_start = GetRangeStart(i);
    int pc_end = GetRangeEnd(i);
    int handler_offset = GetRangeHandler(i);
    int handler_data = GetRangeData(i);
    CatchPrediction prediction = GetRangePrediction(i);
    os << "  (" << std::setw(4) << pc_start << "," << std::setw(4) << pc_end
       << ")  ->  " << std::setw(4) << handler_offset
       << " (prediction=" << prediction << ", data=" << handler_data << ")\n";
  }
}

void HandlerTable::HandlerTableReturnPrint(std::ostream& os) {
249
  os << "  offset   handler\n";
250 251 252
  for (int i = 0; i < NumberOfReturnEntries(); ++i) {
    int pc_offset = GetReturnOffset(i);
    int handler_offset = GetReturnHandler(i);
253 254
    os << std::hex << "    " << std::setw(4) << pc_offset << "  ->  "
       << std::setw(4) << handler_offset << std::dec << "\n";
255 256 257 258 259 260 261
  }
}

#endif  // ENABLE_DISASSEMBLER

}  // namespace internal
}  // namespace v8