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.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     ASSERT(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     ASSERT(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     ASSERT(is_valid());
  59     return ArgumentsField::decode(info_);
  60   }
  61
  62   bool has_doubles() const {
  63     ASSERT(is_valid());
  64     return SaveDoublesField::decode(info_);
  65   }
  66
  67   uint8_t* bits() {
  68     ASSERT(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     ASSERT(index < length_);
  93     return Memory::uint32_at(GetPcOffsetLocation(index));
  94   }
  95
  96   SafepointEntry GetEntry(unsigned index) const {
  97     ASSERT(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, FILE* out = stdout) const;
 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(FILE* out, uint8_t byte, int digits);
 130
 131   DisallowHeapAllocation no_allocation_;
 132   Code* code_;
 133   unsigned length_;
 134   unsigned entry_size_;
 135
 136   Address pc_and_deoptimization_indexes_;
 137   Address entries_;
 138
 139   friend class SafepointTableBuilder;
 140   friend class SafepointEntry;
 141
 142   DISALLOW_COPY_AND_ASSIGN(SafepointTable);
 143 };
 144
 145
 146 class Safepoint BASE_EMBEDDED {
 147  public:
 148   typedef enum {
 149     kSimple = 0,
 150     kWithRegisters = 1 << 0,
 151     kWithDoubles = 1 << 1,
 152     kWithRegistersAndDoubles = kWithRegisters | kWithDoubles
 153   } Kind;
 154
 155   enum DeoptMode {
 156     kNoLazyDeopt,
 157     kLazyDeopt
 158   };
 159
 160   static const int kNoDeoptimizationIndex =
 161       (1 << (SafepointEntry::kDeoptIndexBits)) - 1;
 162
 163   void DefinePointerSlot(int index, Zone* zone) { indexes_->Add(index, zone); }
 164   void DefinePointerRegister(Register reg, Zone* zone);
 165
 166  private:
 167   Safepoint(ZoneList<int>* indexes, ZoneList<int>* registers) :
 168       indexes_(indexes), registers_(registers) { }
 169   ZoneList<int>* indexes_;
 170   ZoneList<int>* registers_;
 171
 172   friend class SafepointTableBuilder;
 173 };
 174
 175
 176 class SafepointTableBuilder BASE_EMBEDDED {
 177  public:
 178   explicit SafepointTableBuilder(Zone* zone)
 179       : deoptimization_info_(32, zone),
 180         deopt_index_list_(32, zone),
 181         indexes_(32, zone),
 182         registers_(32, zone),
 183         emitted_(false),
 184         last_lazy_safepoint_(0),
 185         zone_(zone) { }
 186
 187   // Get the offset of the emitted safepoint table in the code.
 188   unsigned GetCodeOffset() const;
 189
 190   // Define a new safepoint for the current position in the body.
 191   Safepoint DefineSafepoint(Assembler* assembler,
 192                             Safepoint::Kind kind,
 193                             int arguments,
 194                             Safepoint::DeoptMode mode);
 195
 196   // Record deoptimization index for lazy deoptimization for the last
 197   // outstanding safepoints.
 198   void RecordLazyDeoptimizationIndex(int index);
 199   void BumpLastLazySafepointIndex() {
 200     last_lazy_safepoint_ = deopt_index_list_.length();
 201   }
 202
 203   // Emit the safepoint table after the body. The number of bits per
 204   // entry must be enough to hold all the pointer indexes.
 205   void Emit(Assembler* assembler, int bits_per_entry);
 206
 207
 208  private:
 209   struct DeoptimizationInfo {
 210     unsigned pc;
 211     unsigned arguments;
 212     bool has_doubles;
 213   };
 214
 215   uint32_t EncodeExceptPC(const DeoptimizationInfo& info, unsigned index);
 216
 217   ZoneList<DeoptimizationInfo> deoptimization_info_;
 218   ZoneList<unsigned> deopt_index_list_;
 219   ZoneList<ZoneList<int>*> indexes_;
 220   ZoneList<ZoneList<int>*> registers_;
 221
 222   unsigned offset_;
 223   bool emitted_;
 224   int last_lazy_safepoint_;
 225
 226   Zone* zone_;
 227
 228   DISALLOW_COPY_AND_ASSIGN(SafepointTableBuilder);
 229 };
 230
 231 } }  // namespace v8::internal
 232
 233 #endif  // V8_SAFEPOINT_TABLE_H_