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/zone.h" 12 13 namespace v8 { 14 namespace internal { 15 16 struct Register; 17 18 class SafepointEntry BASE_EMBEDDED { 19 public: SafepointEntry()20 SafepointEntry() : info_(0), bits_(NULL) {} 21 SafepointEntry(unsigned info,uint8_t * bits)22 SafepointEntry(unsigned info, uint8_t* bits) : info_(info), bits_(bits) { 23 DCHECK(is_valid()); 24 } 25 is_valid()26 bool is_valid() const { return bits_ != NULL; } 27 Equals(const SafepointEntry & other)28 bool Equals(const SafepointEntry& other) const { 29 return info_ == other.info_ && bits_ == other.bits_; 30 } 31 Reset()32 void Reset() { 33 info_ = 0; 34 bits_ = NULL; 35 } 36 deoptimization_index()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 argument_count()57 int argument_count() const { 58 DCHECK(is_valid()); 59 return ArgumentsField::decode(info_); 60 } 61 has_doubles()62 bool has_doubles() const { 63 DCHECK(is_valid()); 64 return SaveDoublesField::decode(info_); 65 } 66 bits()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 size()85 int size() const { 86 return kHeaderSize + 87 (length_ * (kPcAndDeoptimizationIndexSize + entry_size_)); 88 } length()89 unsigned length() const { return length_; } entry_size()90 unsigned entry_size() const { return entry_size_; } 91 GetPcOffset(unsigned index)92 unsigned GetPcOffset(unsigned index) const { 93 DCHECK(index < length_); 94 return Memory::uint32_at(GetPcOffsetLocation(index)); 95 } 96 GetEntry(unsigned index)97 SafepointEntry GetEntry(unsigned index) const { 98 DCHECK(index < length_); 99 unsigned info = Memory::uint32_at(GetInfoLocation(index)); 100 uint8_t* bits = &Memory::uint8_at(entries_ + (index * entry_size_)); 101 return SafepointEntry(info, bits); 102 } 103 104 // Returns the entry for the given pc. 105 SafepointEntry FindEntry(Address pc) const; 106 107 void PrintEntry(unsigned index, std::ostream& os) const; // NOLINT 108 109 private: 110 static const uint8_t kNoRegisters = 0xFF; 111 112 static const int kLengthOffset = 0; 113 static const int kEntrySizeOffset = kLengthOffset + kIntSize; 114 static const int kHeaderSize = kEntrySizeOffset + kIntSize; 115 116 static const int kPcSize = kIntSize; 117 static const int kDeoptimizationIndexSize = kIntSize; 118 static const int kPcAndDeoptimizationIndexSize = 119 kPcSize + kDeoptimizationIndexSize; 120 GetPcOffsetLocation(unsigned index)121 Address GetPcOffsetLocation(unsigned index) const { 122 return pc_and_deoptimization_indexes_ + 123 (index * kPcAndDeoptimizationIndexSize); 124 } 125 GetInfoLocation(unsigned index)126 Address GetInfoLocation(unsigned index) const { 127 return GetPcOffsetLocation(index) + kPcSize; 128 } 129 130 static void PrintBits(std::ostream& os, // NOLINT 131 uint8_t byte, int digits); 132 133 DisallowHeapAllocation no_allocation_; 134 Code* code_; 135 unsigned length_; 136 unsigned entry_size_; 137 138 Address pc_and_deoptimization_indexes_; 139 Address entries_; 140 141 friend class SafepointTableBuilder; 142 friend class SafepointEntry; 143 144 DISALLOW_COPY_AND_ASSIGN(SafepointTable); 145 }; 146 147 148 class Safepoint BASE_EMBEDDED { 149 public: 150 typedef enum { 151 kSimple = 0, 152 kWithRegisters = 1 << 0, 153 kWithDoubles = 1 << 1, 154 kWithRegistersAndDoubles = kWithRegisters | kWithDoubles 155 } Kind; 156 157 enum DeoptMode { 158 kNoLazyDeopt, 159 kLazyDeopt 160 }; 161 162 static const int kNoDeoptimizationIndex = 163 (1 << (SafepointEntry::kDeoptIndexBits)) - 1; 164 DefinePointerSlot(int index,Zone * zone)165 void DefinePointerSlot(int index, Zone* zone) { indexes_->Add(index, zone); } 166 void DefinePointerRegister(Register reg, Zone* zone); 167 168 private: Safepoint(ZoneList<int> * indexes,ZoneList<int> * registers)169 Safepoint(ZoneList<int>* indexes, ZoneList<int>* registers) 170 : indexes_(indexes), registers_(registers) {} 171 ZoneList<int>* indexes_; 172 ZoneList<int>* registers_; 173 174 friend class SafepointTableBuilder; 175 }; 176 177 178 class SafepointTableBuilder BASE_EMBEDDED { 179 public: SafepointTableBuilder(Zone * zone)180 explicit SafepointTableBuilder(Zone* zone) 181 : deoptimization_info_(32, zone), 182 deopt_index_list_(32, zone), 183 indexes_(32, zone), 184 registers_(32, zone), 185 emitted_(false), 186 last_lazy_safepoint_(0), 187 zone_(zone) { } 188 189 // Get the offset of the emitted safepoint table in the code. 190 unsigned GetCodeOffset() const; 191 192 // Define a new safepoint for the current position in the body. 193 Safepoint DefineSafepoint(Assembler* assembler, 194 Safepoint::Kind kind, 195 int arguments, 196 Safepoint::DeoptMode mode); 197 198 // Record deoptimization index for lazy deoptimization for the last 199 // outstanding safepoints. 200 void RecordLazyDeoptimizationIndex(int index); BumpLastLazySafepointIndex()201 void BumpLastLazySafepointIndex() { 202 last_lazy_safepoint_ = deopt_index_list_.length(); 203 } 204 205 // Emit the safepoint table after the body. The number of bits per 206 // entry must be enough to hold all the pointer indexes. 207 void Emit(Assembler* assembler, int bits_per_entry); 208 209 210 private: 211 struct DeoptimizationInfo { 212 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 ZoneList<ZoneList<int>*> indexes_; 222 ZoneList<ZoneList<int>*> registers_; 223 224 unsigned offset_; 225 bool emitted_; 226 int last_lazy_safepoint_; 227 228 Zone* zone_; 229 230 DISALLOW_COPY_AND_ASSIGN(SafepointTableBuilder); 231 }; 232 233 } // namespace internal 234 } // namespace v8 235 236 #endif // V8_SAFEPOINT_TABLE_H_ 237