safepoint-table.h 6.07 KB
Newer Older
1
// Copyright 2011 the V8 project authors. All rights reserved.
2 3
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
4 5 6 7

#ifndef V8_SAFEPOINT_TABLE_H_
#define V8_SAFEPOINT_TABLE_H_

8
#include "src/allocation.h"
9
#include "src/heap/heap.h"
10 11
#include "src/v8memory.h"
#include "src/zone.h"
12 13 14 15

namespace v8 {
namespace internal {

16 17 18
struct Register;

class SafepointEntry BASE_EMBEDDED {
19
 public:
20
  SafepointEntry() : info_(0), bits_(NULL) {}
21

22
  SafepointEntry(unsigned info, uint8_t* bits) : info_(info), bits_(bits) {
23
    DCHECK(is_valid());
24
  }
25

26 27 28 29
  bool is_valid() const { return bits_ != NULL; }

  bool Equals(const SafepointEntry& other) const {
    return info_ == other.info_ && bits_ == other.bits_;
30 31
  }

32 33 34
  void Reset() {
    info_ = 0;
    bits_ = NULL;
35 36
  }

37
  int deoptimization_index() const {
38
    DCHECK(is_valid());
39
    return DeoptimizationIndexField::decode(info_);
40 41
  }

42 43 44 45 46 47 48 49 50 51 52 53 54 55
  static const int kArgumentsFieldBits = 3;
  static const int kSaveDoublesFieldBits = 1;
  static const int kDeoptIndexBits =
      32 - kArgumentsFieldBits - kSaveDoublesFieldBits;
  class DeoptimizationIndexField:
    public BitField<int, 0, kDeoptIndexBits> {};  // NOLINT
  class ArgumentsField:
    public BitField<unsigned,
                    kDeoptIndexBits,
                    kArgumentsFieldBits> {};  // NOLINT
  class SaveDoublesField:
    public BitField<bool,
                    kDeoptIndexBits + kArgumentsFieldBits,
                    kSaveDoublesFieldBits> { }; // NOLINT
56

57
  int argument_count() const {
58
    DCHECK(is_valid());
59 60 61
    return ArgumentsField::decode(info_);
  }

62
  bool has_doubles() const {
63
    DCHECK(is_valid());
64 65 66
    return SaveDoublesField::decode(info_);
  }

67
  uint8_t* bits() {
68
    DCHECK(is_valid());
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
    return bits_;
  }

  bool HasRegisters() const;
  bool HasRegisterAt(int reg_index) const;

 private:
  unsigned info_;
  uint8_t* bits_;
};


class SafepointTable BASE_EMBEDDED {
 public:
  explicit SafepointTable(Code* code);
84

85 86
  int size() const {
    return kHeaderSize +
87
           (length_ * (kPcAndDeoptimizationIndexSize + entry_size_));
88
  }
89 90 91 92
  unsigned length() const { return length_; }
  unsigned entry_size() const { return entry_size_; }

  unsigned GetPcOffset(unsigned index) const {
93
    DCHECK(index < length_);
94 95 96 97
    return Memory::uint32_at(GetPcOffsetLocation(index));
  }

  SafepointEntry GetEntry(unsigned index) const {
98
    DCHECK(index < length_);
99 100
    unsigned info = Memory::uint32_at(GetInfoLocation(index));
    uint8_t* bits = &Memory::uint8_at(entries_ + (index * entry_size_));
101
    return SafepointEntry(info, bits);
102 103 104 105
  }

  // Returns the entry for the given pc.
  SafepointEntry FindEntry(Address pc) const;
106

107
  void PrintEntry(unsigned index, std::ostream& os) const;  // NOLINT
108 109 110 111 112 113 114 115 116 117

 private:
  static const uint8_t kNoRegisters = 0xFF;

  static const int kLengthOffset = 0;
  static const int kEntrySizeOffset = kLengthOffset + kIntSize;
  static const int kHeaderSize = kEntrySizeOffset + kIntSize;

  static const int kPcSize = kIntSize;
  static const int kDeoptimizationIndexSize = kIntSize;
118 119
  static const int kPcAndDeoptimizationIndexSize =
      kPcSize + kDeoptimizationIndexSize;
120 121 122

  Address GetPcOffsetLocation(unsigned index) const {
    return pc_and_deoptimization_indexes_ +
123
           (index * kPcAndDeoptimizationIndexSize);
124 125
  }

126
  Address GetInfoLocation(unsigned index) const {
127 128 129
    return GetPcOffsetLocation(index) + kPcSize;
  }

130
  static void PrintBits(std::ostream& os,  // NOLINT
131
                        uint8_t byte, int digits);
132

133
  DisallowHeapAllocation no_allocation_;
134 135 136 137 138 139 140 141
  Code* code_;
  unsigned length_;
  unsigned entry_size_;

  Address pc_and_deoptimization_indexes_;
  Address entries_;

  friend class SafepointTableBuilder;
142 143 144
  friend class SafepointEntry;

  DISALLOW_COPY_AND_ASSIGN(SafepointTable);
145 146 147 148 149
};


class Safepoint BASE_EMBEDDED {
 public:
150 151 152 153 154 155 156
  typedef enum {
    kSimple = 0,
    kWithRegisters = 1 << 0,
    kWithDoubles = 1 << 1,
    kWithRegistersAndDoubles = kWithRegisters | kWithDoubles
  } Kind;

157 158 159 160 161
  enum DeoptMode {
    kNoLazyDeopt,
    kLazyDeopt
  };

162
  static const int kNoDeoptimizationIndex =
163
      (1 << (SafepointEntry::kDeoptIndexBits)) - 1;
164

165
  void DefinePointerSlot(int index, Zone* zone) { indexes_->Add(index, zone); }
166
  void DefinePointerRegister(Register reg, Zone* zone);
167 168

 private:
169 170
  Safepoint(ZoneList<int>* indexes, ZoneList<int>* registers)
      : indexes_(indexes), registers_(registers) {}
171 172 173 174 175 176 177 178 179
  ZoneList<int>* indexes_;
  ZoneList<int>* registers_;

  friend class SafepointTableBuilder;
};


class SafepointTableBuilder BASE_EMBEDDED {
 public:
180 181 182 183 184
  explicit SafepointTableBuilder(Zone* zone)
      : deoptimization_info_(32, zone),
        deopt_index_list_(32, zone),
        indexes_(32, zone),
        registers_(32, zone),
185
        emitted_(false),
186 187
        last_lazy_safepoint_(0),
        zone_(zone) { }
188 189 190 191 192

  // Get the offset of the emitted safepoint table in the code.
  unsigned GetCodeOffset() const;

  // Define a new safepoint for the current position in the body.
193 194 195
  Safepoint DefineSafepoint(Assembler* assembler,
                            Safepoint::Kind kind,
                            int arguments,
196
                            Safepoint::DeoptMode mode);
197

198 199 200
  // Record deoptimization index for lazy deoptimization for the last
  // outstanding safepoints.
  void RecordLazyDeoptimizationIndex(int index);
201 202 203
  void BumpLastLazySafepointIndex() {
    last_lazy_safepoint_ = deopt_index_list_.length();
  }
lrn@chromium.org's avatar
lrn@chromium.org committed
204

205 206 207 208
  // Emit the safepoint table after the body. The number of bits per
  // entry must be enough to hold all the pointer indexes.
  void Emit(Assembler* assembler, int bits_per_entry);

209

210 211 212
 private:
  struct DeoptimizationInfo {
    unsigned pc;
213
    unsigned arguments;
214
    bool has_doubles;
215 216
  };

217
  uint32_t EncodeExceptPC(const DeoptimizationInfo& info, unsigned index);
218 219

  ZoneList<DeoptimizationInfo> deoptimization_info_;
220
  ZoneList<unsigned> deopt_index_list_;
221 222 223 224
  ZoneList<ZoneList<int>*> indexes_;
  ZoneList<ZoneList<int>*> registers_;

  unsigned offset_;
225
  bool emitted_;
226
  int last_lazy_safepoint_;
227

228 229
  Zone* zone_;

230 231 232 233 234 235
  DISALLOW_COPY_AND_ASSIGN(SafepointTableBuilder);
};

} }  // namespace v8::internal

#endif  // V8_SAFEPOINT_TABLE_H_