kmillikin@chromium.org | 31b1277 | 2011-02-02 16:08:26 +0000 | [diff] [blame] | 1 | // Copyright 2011 the V8 project authors. All rights reserved. |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 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 | |
sgjesse@chromium.org | ea88ce9 | 2011-03-23 11:19:56 +0000 | [diff] [blame] | 28 | #include "v8.h" |
| 29 | |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 30 | #include "safepoint-table.h" |
sgjesse@chromium.org | c6c5718 | 2011-01-17 12:24:25 +0000 | [diff] [blame] | 31 | |
kmillikin@chromium.org | 31b1277 | 2011-02-02 16:08:26 +0000 | [diff] [blame] | 32 | #include "deoptimizer.h" |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 33 | #include "disasm.h" |
sgjesse@chromium.org | c6c5718 | 2011-01-17 12:24:25 +0000 | [diff] [blame] | 34 | #include "macro-assembler.h" |
sgjesse@chromium.org | ea88ce9 | 2011-03-23 11:19:56 +0000 | [diff] [blame] | 35 | #include "zone-inl.h" |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 36 | |
| 37 | namespace v8 { |
| 38 | namespace internal { |
| 39 | |
sgjesse@chromium.org | c6c5718 | 2011-01-17 12:24:25 +0000 | [diff] [blame] | 40 | |
| 41 | bool SafepointEntry::HasRegisters() const { |
| 42 | ASSERT(is_valid()); |
| 43 | ASSERT(IsAligned(kNumSafepointRegisters, kBitsPerByte)); |
| 44 | const int num_reg_bytes = kNumSafepointRegisters >> kBitsPerByteLog2; |
| 45 | for (int i = 0; i < num_reg_bytes; i++) { |
| 46 | if (bits_[i] != SafepointTable::kNoRegisters) return true; |
| 47 | } |
| 48 | return false; |
| 49 | } |
| 50 | |
| 51 | |
| 52 | bool SafepointEntry::HasRegisterAt(int reg_index) const { |
| 53 | ASSERT(is_valid()); |
| 54 | ASSERT(reg_index >= 0 && reg_index < kNumSafepointRegisters); |
| 55 | int byte_index = reg_index >> kBitsPerByteLog2; |
| 56 | int bit_index = reg_index & (kBitsPerByte - 1); |
| 57 | return (bits_[byte_index] & (1 << bit_index)) != 0; |
| 58 | } |
| 59 | |
| 60 | |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 61 | SafepointTable::SafepointTable(Code* code) { |
| 62 | ASSERT(code->kind() == Code::OPTIMIZED_FUNCTION); |
| 63 | code_ = code; |
ricow@chromium.org | 83aa549 | 2011-02-07 12:42:56 +0000 | [diff] [blame] | 64 | Address header = code->instruction_start() + code->safepoint_table_offset(); |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 65 | length_ = Memory::uint32_at(header + kLengthOffset); |
| 66 | entry_size_ = Memory::uint32_at(header + kEntrySizeOffset); |
| 67 | pc_and_deoptimization_indexes_ = header + kHeaderSize; |
| 68 | entries_ = pc_and_deoptimization_indexes_ + |
| 69 | (length_ * kPcAndDeoptimizationIndexSize); |
| 70 | ASSERT(entry_size_ > 0); |
kmillikin@chromium.org | 83e1682 | 2011-09-13 08:21:47 +0000 | [diff] [blame] | 71 | STATIC_ASSERT(SafepointEntry::DeoptimizationIndexField::kMax == |
| 72 | Safepoint::kNoDeoptimizationIndex); |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 73 | } |
| 74 | |
| 75 | |
sgjesse@chromium.org | c6c5718 | 2011-01-17 12:24:25 +0000 | [diff] [blame] | 76 | SafepointEntry SafepointTable::FindEntry(Address pc) const { |
| 77 | unsigned pc_offset = static_cast<unsigned>(pc - code_->instruction_start()); |
| 78 | for (unsigned i = 0; i < length(); i++) { |
| 79 | // TODO(kasperl): Replace the linear search with binary search. |
| 80 | if (GetPcOffset(i) == pc_offset) return GetEntry(i); |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 81 | } |
sgjesse@chromium.org | c6c5718 | 2011-01-17 12:24:25 +0000 | [diff] [blame] | 82 | return SafepointEntry(); |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 83 | } |
| 84 | |
| 85 | |
| 86 | void SafepointTable::PrintEntry(unsigned index) const { |
| 87 | disasm::NameConverter converter; |
sgjesse@chromium.org | c6c5718 | 2011-01-17 12:24:25 +0000 | [diff] [blame] | 88 | SafepointEntry entry = GetEntry(index); |
| 89 | uint8_t* bits = entry.bits(); |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 90 | |
| 91 | // Print the stack slot bits. |
| 92 | if (entry_size_ > 0) { |
| 93 | ASSERT(IsAligned(kNumSafepointRegisters, kBitsPerByte)); |
| 94 | const int first = kNumSafepointRegisters >> kBitsPerByteLog2; |
| 95 | int last = entry_size_ - 1; |
sgjesse@chromium.org | c6c5718 | 2011-01-17 12:24:25 +0000 | [diff] [blame] | 96 | for (int i = first; i < last; i++) PrintBits(bits[i], kBitsPerByte); |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 97 | int last_bits = code_->stack_slots() - ((last - first) * kBitsPerByte); |
sgjesse@chromium.org | c6c5718 | 2011-01-17 12:24:25 +0000 | [diff] [blame] | 98 | PrintBits(bits[last], last_bits); |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 99 | |
| 100 | // Print the registers (if any). |
sgjesse@chromium.org | c6c5718 | 2011-01-17 12:24:25 +0000 | [diff] [blame] | 101 | if (!entry.HasRegisters()) return; |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 102 | for (int j = 0; j < kNumSafepointRegisters; j++) { |
sgjesse@chromium.org | c6c5718 | 2011-01-17 12:24:25 +0000 | [diff] [blame] | 103 | if (entry.HasRegisterAt(j)) { |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 104 | PrintF(" | %s", converter.NameOfCPURegister(j)); |
| 105 | } |
| 106 | } |
| 107 | } |
| 108 | } |
| 109 | |
| 110 | |
| 111 | void SafepointTable::PrintBits(uint8_t byte, int digits) { |
| 112 | ASSERT(digits >= 0 && digits <= kBitsPerByte); |
| 113 | for (int i = 0; i < digits; i++) { |
| 114 | PrintF("%c", ((byte & (1 << i)) == 0) ? '0' : '1'); |
| 115 | } |
| 116 | } |
| 117 | |
| 118 | |
mmassi@chromium.org | 7028c05 | 2012-06-13 11:51:58 +0000 | [diff] [blame] | 119 | void Safepoint::DefinePointerRegister(Register reg, Zone* zone) { |
| 120 | registers_->Add(reg.code(), zone); |
sgjesse@chromium.org | c6c5718 | 2011-01-17 12:24:25 +0000 | [diff] [blame] | 121 | } |
| 122 | |
| 123 | |
ager@chromium.org | 378b34e | 2011-01-28 08:04:38 +0000 | [diff] [blame] | 124 | Safepoint SafepointTableBuilder::DefineSafepoint( |
ricow@chromium.org | 27bf288 | 2011-11-17 08:34:43 +0000 | [diff] [blame] | 125 | Assembler* assembler, |
| 126 | Safepoint::Kind kind, |
| 127 | int arguments, |
| 128 | Safepoint::DeoptMode deopt_mode) { |
sgjesse@chromium.org | c6c5718 | 2011-01-17 12:24:25 +0000 | [diff] [blame] | 129 | ASSERT(arguments >= 0); |
ricow@chromium.org | 27bf288 | 2011-11-17 08:34:43 +0000 | [diff] [blame] | 130 | DeoptimizationInfo info; |
| 131 | info.pc = assembler->pc_offset(); |
| 132 | info.arguments = arguments; |
| 133 | info.has_doubles = (kind & Safepoint::kWithDoubles); |
mmassi@chromium.org | 7028c05 | 2012-06-13 11:51:58 +0000 | [diff] [blame] | 134 | deoptimization_info_.Add(info, zone_); |
| 135 | deopt_index_list_.Add(Safepoint::kNoDeoptimizationIndex, zone_); |
ricow@chromium.org | 27bf288 | 2011-11-17 08:34:43 +0000 | [diff] [blame] | 136 | if (deopt_mode == Safepoint::kNoLazyDeopt) { |
| 137 | last_lazy_safepoint_ = deopt_index_list_.length(); |
| 138 | } |
mmassi@chromium.org | 7028c05 | 2012-06-13 11:51:58 +0000 | [diff] [blame] | 139 | indexes_.Add(new(zone_) ZoneList<int>(8, zone_), zone_); |
ager@chromium.org | 378b34e | 2011-01-28 08:04:38 +0000 | [diff] [blame] | 140 | registers_.Add((kind & Safepoint::kWithRegisters) |
mmassi@chromium.org | 7028c05 | 2012-06-13 11:51:58 +0000 | [diff] [blame] | 141 | ? new(zone_) ZoneList<int>(4, zone_) |
| 142 | : NULL, |
| 143 | zone_); |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 144 | return Safepoint(indexes_.last(), registers_.last()); |
| 145 | } |
| 146 | |
| 147 | |
ricow@chromium.org | 27bf288 | 2011-11-17 08:34:43 +0000 | [diff] [blame] | 148 | void SafepointTableBuilder::RecordLazyDeoptimizationIndex(int index) { |
| 149 | while (last_lazy_safepoint_ < deopt_index_list_.length()) { |
| 150 | deopt_index_list_[last_lazy_safepoint_++] = index; |
| 151 | } |
| 152 | } |
| 153 | |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 154 | unsigned SafepointTableBuilder::GetCodeOffset() const { |
| 155 | ASSERT(emitted_); |
| 156 | return offset_; |
| 157 | } |
| 158 | |
| 159 | |
| 160 | void SafepointTableBuilder::Emit(Assembler* assembler, int bits_per_entry) { |
kmillikin@chromium.org | 31b1277 | 2011-02-02 16:08:26 +0000 | [diff] [blame] | 161 | // For lazy deoptimization we need space to patch a call after every call. |
| 162 | // Ensure there is always space for such patching, even if the code ends |
| 163 | // in a call. |
| 164 | int target_offset = assembler->pc_offset() + Deoptimizer::patch_size(); |
| 165 | while (assembler->pc_offset() < target_offset) { |
| 166 | assembler->nop(); |
| 167 | } |
| 168 | |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 169 | // Make sure the safepoint table is properly aligned. Pad with nops. |
| 170 | assembler->Align(kIntSize); |
| 171 | assembler->RecordComment(";;; Safepoint table."); |
| 172 | offset_ = assembler->pc_offset(); |
| 173 | |
| 174 | // Take the register bits into account. |
| 175 | bits_per_entry += kNumSafepointRegisters; |
| 176 | |
| 177 | // Compute the number of bytes per safepoint entry. |
| 178 | int bytes_per_entry = |
| 179 | RoundUp(bits_per_entry, kBitsPerByte) >> kBitsPerByteLog2; |
| 180 | |
| 181 | // Emit the table header. |
| 182 | int length = deoptimization_info_.length(); |
| 183 | assembler->dd(length); |
| 184 | assembler->dd(bytes_per_entry); |
| 185 | |
ricow@chromium.org | 27bf288 | 2011-11-17 08:34:43 +0000 | [diff] [blame] | 186 | // Emit sorted table of pc offsets together with deoptimization indexes. |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 187 | for (int i = 0; i < length; i++) { |
| 188 | assembler->dd(deoptimization_info_[i].pc); |
ricow@chromium.org | 27bf288 | 2011-11-17 08:34:43 +0000 | [diff] [blame] | 189 | assembler->dd(EncodeExceptPC(deoptimization_info_[i], |
| 190 | deopt_index_list_[i])); |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 191 | } |
| 192 | |
| 193 | // Emit table of bitmaps. |
mmassi@chromium.org | 7028c05 | 2012-06-13 11:51:58 +0000 | [diff] [blame] | 194 | ZoneList<uint8_t> bits(bytes_per_entry, zone_); |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 195 | for (int i = 0; i < length; i++) { |
| 196 | ZoneList<int>* indexes = indexes_[i]; |
| 197 | ZoneList<int>* registers = registers_[i]; |
| 198 | bits.Clear(); |
mmassi@chromium.org | 7028c05 | 2012-06-13 11:51:58 +0000 | [diff] [blame] | 199 | bits.AddBlock(0, bytes_per_entry, zone_); |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 200 | |
| 201 | // Run through the registers (if any). |
| 202 | ASSERT(IsAligned(kNumSafepointRegisters, kBitsPerByte)); |
| 203 | if (registers == NULL) { |
| 204 | const int num_reg_bytes = kNumSafepointRegisters >> kBitsPerByteLog2; |
| 205 | for (int j = 0; j < num_reg_bytes; j++) { |
| 206 | bits[j] = SafepointTable::kNoRegisters; |
| 207 | } |
| 208 | } else { |
| 209 | for (int j = 0; j < registers->length(); j++) { |
| 210 | int index = registers->at(j); |
| 211 | ASSERT(index >= 0 && index < kNumSafepointRegisters); |
| 212 | int byte_index = index >> kBitsPerByteLog2; |
| 213 | int bit_index = index & (kBitsPerByte - 1); |
| 214 | bits[byte_index] |= (1 << bit_index); |
| 215 | } |
| 216 | } |
| 217 | |
| 218 | // Run through the indexes and build a bitmap. |
| 219 | for (int j = 0; j < indexes->length(); j++) { |
| 220 | int index = bits_per_entry - 1 - indexes->at(j); |
| 221 | int byte_index = index >> kBitsPerByteLog2; |
| 222 | int bit_index = index & (kBitsPerByte - 1); |
| 223 | bits[byte_index] |= (1U << bit_index); |
| 224 | } |
| 225 | |
| 226 | // Emit the bitmap for the current entry. |
| 227 | for (int k = 0; k < bytes_per_entry; k++) { |
| 228 | assembler->db(bits[k]); |
| 229 | } |
| 230 | } |
| 231 | emitted_ = true; |
| 232 | } |
| 233 | |
| 234 | |
ricow@chromium.org | 27bf288 | 2011-11-17 08:34:43 +0000 | [diff] [blame] | 235 | uint32_t SafepointTableBuilder::EncodeExceptPC(const DeoptimizationInfo& info, |
| 236 | unsigned index) { |
sgjesse@chromium.org | c6c5718 | 2011-01-17 12:24:25 +0000 | [diff] [blame] | 237 | uint32_t encoding = SafepointEntry::DeoptimizationIndexField::encode(index); |
sgjesse@chromium.org | c6c5718 | 2011-01-17 12:24:25 +0000 | [diff] [blame] | 238 | encoding |= SafepointEntry::ArgumentsField::encode(info.arguments); |
| 239 | encoding |= SafepointEntry::SaveDoublesField::encode(info.has_doubles); |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 240 | return encoding; |
| 241 | } |
| 242 | |
| 243 | |
ricow@chromium.org | 83aa549 | 2011-02-07 12:42:56 +0000 | [diff] [blame] | 244 | |
kasperl@chromium.org | a555126 | 2010-12-07 12:49:48 +0000 | [diff] [blame] | 245 | } } // namespace v8::internal |