src/safepoint-table.h

   1 // Copyright 2011 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #ifndef V8_SAFEPOINT_TABLE_H_
  29 #define V8_SAFEPOINT_TABLE_H_
  30
  31 #include "allocation.h"
  32 #include "heap.h"
  33 #include "v8memory.h"
  34 #include "zone.h"
  35
  36 namespace v8 {
  37 namespace internal {
  38
  39 struct Register;
  40
  41 class SafepointEntry BASE_EMBEDDED {
  42  public:
  43   SafepointEntry() : info_(0), bits_(NULL) {}
  44
  45   SafepointEntry(unsigned info, uint8_t* bits) : info_(info), bits_(bits) {
  46     ASSERT(is_valid());
  47   }
  48
  49   bool is_valid() const { return bits_ != NULL; }
  50
  51   bool Equals(const SafepointEntry& other) const {
  52     return info_ == other.info_ && bits_ == other.bits_;
  53   }
  54
  55   void Reset() {
  56     info_ = 0;
  57     bits_ = NULL;
  58   }
  59
  60   int deoptimization_index() const {
  61     ASSERT(is_valid());
  62     return DeoptimizationIndexField::decode(info_);
  63   }
  64
  65   static const int kArgumentsFieldBits = 3;
  66   static const int kSaveDoublesFieldBits = 1;
  67   static const int kDeoptIndexBits =
  68       32 - kArgumentsFieldBits - kSaveDoublesFieldBits;
  69   class DeoptimizationIndexField:
  70     public BitField<int, 0, kDeoptIndexBits> {};  // NOLINT
  71   class ArgumentsField:
  72     public BitField<unsigned,
  73                     kDeoptIndexBits,
  74                     kArgumentsFieldBits> {};  // NOLINT
  75   class SaveDoublesField:
  76     public BitField<bool,
  77                     kDeoptIndexBits + kArgumentsFieldBits,
  78                     kSaveDoublesFieldBits> { }; // NOLINT
  79
  80   int argument_count() const {
  81     ASSERT(is_valid());
  82     return ArgumentsField::decode(info_);
  83   }
  84
  85   bool has_doubles() const {
  86     ASSERT(is_valid());
  87     return SaveDoublesField::decode(info_);
  88   }
  89
  90   uint8_t* bits() {
  91     ASSERT(is_valid());
  92     return bits_;
  93   }
  94
  95   bool HasRegisters() const;
  96   bool HasRegisterAt(int reg_index) const;
  97
  98  private:
  99   unsigned info_;
 100   uint8_t* bits_;
 101 };
 102
 103
 104 class SafepointTable BASE_EMBEDDED {
 105  public:
 106   explicit SafepointTable(Code* code);
 107
 108   int size() const {
 109     return kHeaderSize +
 110            (length_ * (kPcAndDeoptimizationIndexSize + entry_size_)); }
 111   unsigned length() const { return length_; }
 112   unsigned entry_size() const { return entry_size_; }
 113
 114   unsigned GetPcOffset(unsigned index) const {
 115     ASSERT(index < length_);
 116     return Memory::uint32_at(GetPcOffsetLocation(index));
 117   }
 118
 119   SafepointEntry GetEntry(unsigned index) const {
 120     ASSERT(index < length_);
 121     unsigned info = Memory::uint32_at(GetInfoLocation(index));
 122     uint8_t* bits = &Memory::uint8_at(entries_ + (index * entry_size_));
 123     return SafepointEntry(info, bits);
 124   }
 125
 126   // Returns the entry for the given pc.
 127   SafepointEntry FindEntry(Address pc) const;
 128
 129   void PrintEntry(unsigned index, FILE* out = stdout) const;
 130
 131  private:
 132   static const uint8_t kNoRegisters = 0xFF;
 133
 134   static const int kLengthOffset = 0;
 135   static const int kEntrySizeOffset = kLengthOffset + kIntSize;
 136   static const int kHeaderSize = kEntrySizeOffset + kIntSize;
 137
 138   static const int kPcSize = kIntSize;
 139   static const int kDeoptimizationIndexSize = kIntSize;
 140   static const int kPcAndDeoptimizationIndexSize =
 141       kPcSize + kDeoptimizationIndexSize;
 142
 143   Address GetPcOffsetLocation(unsigned index) const {
 144     return pc_and_deoptimization_indexes_ +
 145            (index * kPcAndDeoptimizationIndexSize);
 146   }
 147
 148   Address GetInfoLocation(unsigned index) const {
 149     return GetPcOffsetLocation(index) + kPcSize;
 150   }
 151
 152   static void PrintBits(FILE* out, uint8_t byte, int digits);
 153
 154   DisallowHeapAllocation no_allocation_;
 155   Code* code_;
 156   unsigned length_;
 157   unsigned entry_size_;
 158
 159   Address pc_and_deoptimization_indexes_;
 160   Address entries_;
 161
 162   friend class SafepointTableBuilder;
 163   friend class SafepointEntry;
 164
 165   DISALLOW_COPY_AND_ASSIGN(SafepointTable);
 166 };
 167
 168
 169 class Safepoint BASE_EMBEDDED {
 170  public:
 171   typedef enum {
 172     kSimple = 0,
 173     kWithRegisters = 1 << 0,
 174     kWithDoubles = 1 << 1,
 175     kWithRegistersAndDoubles = kWithRegisters | kWithDoubles
 176   } Kind;
 177
 178   enum DeoptMode {
 179     kNoLazyDeopt,
 180     kLazyDeopt
 181   };
 182
 183   static const int kNoDeoptimizationIndex =
 184       (1 << (SafepointEntry::kDeoptIndexBits)) - 1;
 185
 186   void DefinePointerSlot(int index, Zone* zone) { indexes_->Add(index, zone); }
 187   void DefinePointerRegister(Register reg, Zone* zone);
 188
 189  private:
 190   Safepoint(ZoneList<int>* indexes, ZoneList<int>* registers) :
 191       indexes_(indexes), registers_(registers) { }
 192   ZoneList<int>* indexes_;
 193   ZoneList<int>* registers_;
 194
 195   friend class SafepointTableBuilder;
 196 };
 197
 198
 199 class SafepointTableBuilder BASE_EMBEDDED {
 200  public:
 201   explicit SafepointTableBuilder(Zone* zone)
 202       : deoptimization_info_(32, zone),
 203         deopt_index_list_(32, zone),
 204         indexes_(32, zone),
 205         registers_(32, zone),
 206         emitted_(false),
 207         last_lazy_safepoint_(0),
 208         zone_(zone) { }
 209
 210   // Get the offset of the emitted safepoint table in the code.
 211   unsigned GetCodeOffset() const;
 212
 213   // Define a new safepoint for the current position in the body.
 214   Safepoint DefineSafepoint(Assembler* assembler,
 215                             Safepoint::Kind kind,
 216                             int arguments,
 217                             Safepoint::DeoptMode mode);
 218
 219   // Record deoptimization index for lazy deoptimization for the last
 220   // outstanding safepoints.
 221   void RecordLazyDeoptimizationIndex(int index);
 222
 223   // Emit the safepoint table after the body. The number of bits per
 224   // entry must be enough to hold all the pointer indexes.
 225   void Emit(Assembler* assembler, int bits_per_entry);
 226
 227
 228  private:
 229   struct DeoptimizationInfo {
 230     unsigned pc;
 231     unsigned arguments;
 232     bool has_doubles;
 233   };
 234
 235   uint32_t EncodeExceptPC(const DeoptimizationInfo& info, unsigned index);
 236
 237   ZoneList<DeoptimizationInfo> deoptimization_info_;
 238   ZoneList<unsigned> deopt_index_list_;
 239   ZoneList<ZoneList<int>*> indexes_;
 240   ZoneList<ZoneList<int>*> registers_;
 241
 242   unsigned offset_;
 243   bool emitted_;
 244   int last_lazy_safepoint_;
 245
 246   Zone* zone_;
 247
 248   DISALLOW_COPY_AND_ASSIGN(SafepointTableBuilder);
 249 };
 250
 251 } }  // namespace v8::internal
 252
 253 #endif  // V8_SAFEPOINT_TABLE_H_