src/safepoint-table.h

   1 // Copyright 2011 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_SAFEPOINT_TABLE_H_
   6 #define V8_SAFEPOINT_TABLE_H_
   7
   8 #include "src/allocation.h"
   9 #include "src/heap/heap.h"
  10 #include "src/v8memory.h"
  11 #include "src/zone.h"
  12
  13 namespace v8 {
  14 namespace internal {
  15
  16 struct Register;
  17
  18 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   bool is_valid() const { return bits_ != NULL; }
  27
  28   bool Equals(const SafepointEntry& other) const {
  29     return info_ == other.info_ && bits_ == other.bits_;
  30   }
  31
  32   void Reset() {
  33     info_ = 0;
  34     bits_ = NULL;
  35   }
  36
  37   int deoptimization_index() const {
  38     DCHECK(is_valid());
  39     return DeoptimizationIndexField::decode(info_);
  40   }
  41
  42   static const int kArgumentsFieldBits = 3;
  43   static const int kSaveDoublesFieldBits = 1;
  44   static const int kDeoptIndexBits =
  45       32 - kArgumentsFieldBits - kSaveDoublesFieldBits;
  46   class DeoptimizationIndexField:
  47     public BitField<int, 0, kDeoptIndexBits> {};  // NOLINT
  48   class ArgumentsField:
  49     public BitField<unsigned,
  50                     kDeoptIndexBits,
  51                     kArgumentsFieldBits> {};  // NOLINT
  52   class SaveDoublesField:
  53     public BitField<bool,
  54                     kDeoptIndexBits + kArgumentsFieldBits,
  55                     kSaveDoublesFieldBits> { }; // NOLINT
  56
  57   int argument_count() const {
  58     DCHECK(is_valid());
  59     return ArgumentsField::decode(info_);
  60   }
  61
  62   bool has_doubles() const {
  63     DCHECK(is_valid());
  64     return SaveDoublesField::decode(info_);
  65   }
  66
  67   uint8_t* bits() {
  68     DCHECK(is_valid());
  69     return bits_;
  70   }
  71
  72   bool HasRegisters() const;
  73   bool HasRegisterAt(int reg_index) const;
  74
  75  private:
  76   unsigned info_;
  77   uint8_t* bits_;
  78 };
  79
  80
  81 class SafepointTable BASE_EMBEDDED {
  82  public:
  83   explicit SafepointTable(Code* code);
  84
  85   int size() const {
  86     return kHeaderSize +
  87            (length_ * (kPcAndDeoptimizationIndexSize + entry_size_)); }
  88   unsigned length() const { return length_; }
  89   unsigned entry_size() const { return entry_size_; }
  90
  91   unsigned GetPcOffset(unsigned index) const {
  92     DCHECK(index < length_);
  93     return Memory::uint32_at(GetPcOffsetLocation(index));
  94   }
  95
  96   SafepointEntry GetEntry(unsigned index) const {
  97     DCHECK(index < length_);
  98     unsigned info = Memory::uint32_at(GetInfoLocation(index));
  99     uint8_t* bits = &Memory::uint8_at(entries_ + (index * entry_size_));
 100     return SafepointEntry(info, bits);
 101   }
 102
 103   // Returns the entry for the given pc.
 104   SafepointEntry FindEntry(Address pc) const;
 105
 106   void PrintEntry(unsigned index, OStream& os) const;  // NOLINT
 107
 108  private:
 109   static const uint8_t kNoRegisters = 0xFF;
 110
 111   static const int kLengthOffset = 0;
 112   static const int kEntrySizeOffset = kLengthOffset + kIntSize;
 113   static const int kHeaderSize = kEntrySizeOffset + kIntSize;
 114
 115   static const int kPcSize = kIntSize;
 116   static const int kDeoptimizationIndexSize = kIntSize;
 117   static const int kPcAndDeoptimizationIndexSize =
 118       kPcSize + kDeoptimizationIndexSize;
 119
 120   Address GetPcOffsetLocation(unsigned index) const {
 121     return pc_and_deoptimization_indexes_ +
 122            (index * kPcAndDeoptimizationIndexSize);
 123   }
 124
 125   Address GetInfoLocation(unsigned index) const {
 126     return GetPcOffsetLocation(index) + kPcSize;
 127   }
 128
 129   static void PrintBits(OStream& os,  // NOLINT
 130                         uint8_t byte, int digits);
 131
 132   DisallowHeapAllocation no_allocation_;
 133   Code* code_;
 134   unsigned length_;
 135   unsigned entry_size_;
 136
 137   Address pc_and_deoptimization_indexes_;
 138   Address entries_;
 139
 140   friend class SafepointTableBuilder;
 141   friend class SafepointEntry;
 142
 143   DISALLOW_COPY_AND_ASSIGN(SafepointTable);
 144 };
 145
 146
 147 class Safepoint BASE_EMBEDDED {
 148  public:
 149   typedef enum {
 150     kSimple = 0,
 151     kWithRegisters = 1 << 0,
 152     kWithDoubles = 1 << 1,
 153     kWithRegistersAndDoubles = kWithRegisters | kWithDoubles
 154   } Kind;
 155
 156   enum DeoptMode {
 157     kNoLazyDeopt,
 158     kLazyDeopt
 159   };
 160
 161   static const int kNoDeoptimizationIndex =
 162       (1 << (SafepointEntry::kDeoptIndexBits)) - 1;
 163
 164   void DefinePointerSlot(int index, Zone* zone) { indexes_->Add(index, zone); }
 165   void DefinePointerRegister(Register reg, Zone* zone);
 166
 167  private:
 168   Safepoint(ZoneList<int>* indexes, ZoneList<int>* registers) :
 169       indexes_(indexes), registers_(registers) { }
 170   ZoneList<int>* indexes_;
 171   ZoneList<int>* registers_;
 172
 173   friend class SafepointTableBuilder;
 174 };
 175
 176
 177 class SafepointTableBuilder BASE_EMBEDDED {
 178  public:
 179   explicit SafepointTableBuilder(Zone* zone)
 180       : deoptimization_info_(32, zone),
 181         deopt_index_list_(32, zone),
 182         indexes_(32, zone),
 183         registers_(32, zone),
 184         emitted_(false),
 185         last_lazy_safepoint_(0),
 186         zone_(zone) { }
 187
 188   // Get the offset of the emitted safepoint table in the code.
 189   unsigned GetCodeOffset() const;
 190
 191   // Define a new safepoint for the current position in the body.
 192   Safepoint DefineSafepoint(Assembler* assembler,
 193                             Safepoint::Kind kind,
 194                             int arguments,
 195                             Safepoint::DeoptMode mode);
 196
 197   // Record deoptimization index for lazy deoptimization for the last
 198   // outstanding safepoints.
 199   void RecordLazyDeoptimizationIndex(int index);
 200   void BumpLastLazySafepointIndex() {
 201     last_lazy_safepoint_ = deopt_index_list_.length();
 202   }
 203
 204   // Emit the safepoint table after the body. The number of bits per
 205   // entry must be enough to hold all the pointer indexes.
 206   void Emit(Assembler* assembler, int bits_per_entry);
 207
 208
 209  private:
 210   struct DeoptimizationInfo {
 211     unsigned pc;
 212     unsigned arguments;
 213     bool has_doubles;
 214   };
 215
 216   uint32_t EncodeExceptPC(const DeoptimizationInfo& info, unsigned index);
 217
 218   ZoneList<DeoptimizationInfo> deoptimization_info_;
 219   ZoneList<unsigned> deopt_index_list_;
 220   ZoneList<ZoneList<int>*> indexes_;
 221   ZoneList<ZoneList<int>*> registers_;
 222
 223   unsigned offset_;
 224   bool emitted_;
 225   int last_lazy_safepoint_;
 226
 227   Zone* zone_;
 228
 229   DISALLOW_COPY_AND_ASSIGN(SafepointTableBuilder);
 230 };
 231
 232 } }  // namespace v8::internal
 233
 234 #endif  // V8_SAFEPOINT_TABLE_H_