1 // Copyright 2012 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 #if V8_TARGET_ARCH_X87 6 7 #include "src/codegen.h" 8 #include "src/deoptimizer.h" 9 #include "src/full-codegen/full-codegen.h" 10 #include "src/register-configuration.h" 11 #include "src/safepoint-table.h" 12 #include "src/x87/frames-x87.h" 13 14 namespace v8 { 15 namespace internal { 16 17 const int Deoptimizer::table_entry_size_ = 10; 18 19 20 int Deoptimizer::patch_size() { 21 return Assembler::kCallInstructionLength; 22 } 23 24 25 void Deoptimizer::EnsureRelocSpaceForLazyDeoptimization(Handle<Code> code) { 26 Isolate* isolate = code->GetIsolate(); 27 HandleScope scope(isolate); 28 29 // Compute the size of relocation information needed for the code 30 // patching in Deoptimizer::PatchCodeForDeoptimization below. 31 int min_reloc_size = 0; 32 int prev_pc_offset = 0; 33 DeoptimizationInputData* deopt_data = 34 DeoptimizationInputData::cast(code->deoptimization_data()); 35 for (int i = 0; i < deopt_data->DeoptCount(); i++) { 36 int pc_offset = deopt_data->Pc(i)->value(); 37 if (pc_offset == -1) continue; 38 pc_offset = pc_offset + 1; // We will encode the pc offset after the call. 39 DCHECK_GE(pc_offset, prev_pc_offset); 40 int pc_delta = pc_offset - prev_pc_offset; 41 // We use RUNTIME_ENTRY reloc info which has a size of 2 bytes 42 // if encodable with small pc delta encoding and up to 6 bytes 43 // otherwise. 44 if (pc_delta <= RelocInfo::kMaxSmallPCDelta) { 45 min_reloc_size += 2; 46 } else { 47 min_reloc_size += 6; 48 } 49 prev_pc_offset = pc_offset; 50 } 51 52 // If the relocation information is not big enough we create a new 53 // relocation info object that is padded with comments to make it 54 // big enough for lazy doptimization. 55 int reloc_length = code->relocation_info()->length(); 56 if (min_reloc_size > reloc_length) { 57 int comment_reloc_size = RelocInfo::kMinRelocCommentSize; 58 // Padding needed. 59 int min_padding = min_reloc_size - reloc_length; 60 // Number of comments needed to take up at least that much space. 61 int additional_comments = 62 (min_padding + comment_reloc_size - 1) / comment_reloc_size; 63 // Actual padding size. 64 int padding = additional_comments * comment_reloc_size; 65 // Allocate new relocation info and copy old relocation to the end 66 // of the new relocation info array because relocation info is 67 // written and read backwards. 68 Factory* factory = isolate->factory(); 69 Handle<ByteArray> new_reloc = 70 factory->NewByteArray(reloc_length + padding, TENURED); 71 MemCopy(new_reloc->GetDataStartAddress() + padding, 72 code->relocation_info()->GetDataStartAddress(), reloc_length); 73 // Create a relocation writer to write the comments in the padding 74 // space. Use position 0 for everything to ensure short encoding. 75 RelocInfoWriter reloc_info_writer( 76 new_reloc->GetDataStartAddress() + padding, 0); 77 intptr_t comment_string 78 = reinterpret_cast<intptr_t>(RelocInfo::kFillerCommentString); 79 RelocInfo rinfo(isolate, 0, RelocInfo::COMMENT, comment_string, NULL); 80 for (int i = 0; i < additional_comments; ++i) { 81 #ifdef DEBUG 82 byte* pos_before = reloc_info_writer.pos(); 83 #endif 84 reloc_info_writer.Write(&rinfo); 85 DCHECK(RelocInfo::kMinRelocCommentSize == 86 pos_before - reloc_info_writer.pos()); 87 } 88 // Replace relocation information on the code object. 89 code->set_relocation_info(*new_reloc); 90 } 91 } 92 93 94 void Deoptimizer::PatchCodeForDeoptimization(Isolate* isolate, Code* code) { 95 Address code_start_address = code->instruction_start(); 96 97 if (FLAG_zap_code_space) { 98 // Fail hard and early if we enter this code object again. 99 byte* pointer = code->FindCodeAgeSequence(); 100 if (pointer != NULL) { 101 pointer += kNoCodeAgeSequenceLength; 102 } else { 103 pointer = code->instruction_start(); 104 } 105 CodePatcher patcher(isolate, pointer, 1); 106 patcher.masm()->int3(); 107 108 DeoptimizationInputData* data = 109 DeoptimizationInputData::cast(code->deoptimization_data()); 110 int osr_offset = data->OsrPcOffset()->value(); 111 if (osr_offset > 0) { 112 CodePatcher osr_patcher(isolate, code->instruction_start() + osr_offset, 113 1); 114 osr_patcher.masm()->int3(); 115 } 116 } 117 118 // We will overwrite the code's relocation info in-place. Relocation info 119 // is written backward. The relocation info is the payload of a byte 120 // array. Later on we will slide this to the start of the byte array and 121 // create a filler object in the remaining space. 122 ByteArray* reloc_info = code->relocation_info(); 123 Address reloc_end_address = reloc_info->address() + reloc_info->Size(); 124 RelocInfoWriter reloc_info_writer(reloc_end_address, code_start_address); 125 126 // Since the call is a relative encoding, write new 127 // reloc info. We do not need any of the existing reloc info because the 128 // existing code will not be used again (we zap it in debug builds). 129 // 130 // Emit call to lazy deoptimization at all lazy deopt points. 131 DeoptimizationInputData* deopt_data = 132 DeoptimizationInputData::cast(code->deoptimization_data()); 133 #ifdef DEBUG 134 Address prev_call_address = NULL; 135 #endif 136 // For each LLazyBailout instruction insert a call to the corresponding 137 // deoptimization entry. 138 for (int i = 0; i < deopt_data->DeoptCount(); i++) { 139 if (deopt_data->Pc(i)->value() == -1) continue; 140 // Patch lazy deoptimization entry. 141 Address call_address = code_start_address + deopt_data->Pc(i)->value(); 142 CodePatcher patcher(isolate, call_address, patch_size()); 143 Address deopt_entry = GetDeoptimizationEntry(isolate, i, LAZY); 144 patcher.masm()->call(deopt_entry, RelocInfo::NONE32); 145 // We use RUNTIME_ENTRY for deoptimization bailouts. 146 RelocInfo rinfo(isolate, call_address + 1, // 1 after the call opcode. 147 RelocInfo::RUNTIME_ENTRY, 148 reinterpret_cast<intptr_t>(deopt_entry), NULL); 149 reloc_info_writer.Write(&rinfo); 150 DCHECK_GE(reloc_info_writer.pos(), 151 reloc_info->address() + ByteArray::kHeaderSize); 152 DCHECK(prev_call_address == NULL || 153 call_address >= prev_call_address + patch_size()); 154 DCHECK(call_address + patch_size() <= code->instruction_end()); 155 #ifdef DEBUG 156 prev_call_address = call_address; 157 #endif 158 } 159 160 // Move the relocation info to the beginning of the byte array. 161 const int new_reloc_length = reloc_end_address - reloc_info_writer.pos(); 162 MemMove(code->relocation_start(), reloc_info_writer.pos(), new_reloc_length); 163 164 // Right trim the relocation info to free up remaining space. 165 const int delta = reloc_info->length() - new_reloc_length; 166 if (delta > 0) { 167 isolate->heap()->RightTrimFixedArray(reloc_info, delta); 168 } 169 } 170 171 172 void Deoptimizer::SetPlatformCompiledStubRegisters( 173 FrameDescription* output_frame, CodeStubDescriptor* descriptor) { 174 intptr_t handler = 175 reinterpret_cast<intptr_t>(descriptor->deoptimization_handler()); 176 int params = descriptor->GetHandlerParameterCount(); 177 output_frame->SetRegister(eax.code(), params); 178 output_frame->SetRegister(ebx.code(), handler); 179 } 180 181 182 void Deoptimizer::CopyDoubleRegisters(FrameDescription* output_frame) { 183 for (int i = 0; i < X87Register::kMaxNumRegisters; ++i) { 184 Float64 double_value = input_->GetDoubleRegister(i); 185 output_frame->SetDoubleRegister(i, double_value); 186 } 187 } 188 189 #define __ masm()-> 190 191 void Deoptimizer::TableEntryGenerator::Generate() { 192 GeneratePrologue(); 193 194 // Save all general purpose registers before messing with them. 195 const int kNumberOfRegisters = Register::kNumRegisters; 196 197 const int kDoubleRegsSize = kDoubleSize * X87Register::kMaxNumRegisters; 198 199 // Reserve space for x87 fp registers. 200 __ sub(esp, Immediate(kDoubleRegsSize)); 201 202 __ pushad(); 203 204 ExternalReference c_entry_fp_address(Isolate::kCEntryFPAddress, isolate()); 205 __ mov(Operand::StaticVariable(c_entry_fp_address), ebp); 206 207 // GP registers are safe to use now. 208 // Save used x87 fp registers in correct position of previous reserve space. 209 Label loop, done; 210 // Get the layout of x87 stack. 211 __ sub(esp, Immediate(kPointerSize)); 212 __ fistp_s(MemOperand(esp, 0)); 213 __ pop(eax); 214 // Preserve stack layout in edi 215 __ mov(edi, eax); 216 // Get the x87 stack depth, the first 3 bits. 217 __ mov(ecx, eax); 218 __ and_(ecx, 0x7); 219 __ j(zero, &done, Label::kNear); 220 221 __ bind(&loop); 222 __ shr(eax, 0x3); 223 __ mov(ebx, eax); 224 __ and_(ebx, 0x7); // Extract the st_x index into ebx. 225 // Pop TOS to the correct position. The disp(0x20) is due to pushad. 226 // The st_i should be saved to (esp + ebx * kDoubleSize + 0x20). 227 __ fstp_d(Operand(esp, ebx, times_8, 0x20)); 228 __ dec(ecx); // Decrease stack depth. 229 __ j(not_zero, &loop, Label::kNear); 230 __ bind(&done); 231 232 const int kSavedRegistersAreaSize = 233 kNumberOfRegisters * kPointerSize + kDoubleRegsSize; 234 235 // Get the bailout id from the stack. 236 __ mov(ebx, Operand(esp, kSavedRegistersAreaSize)); 237 238 // Get the address of the location in the code object 239 // and compute the fp-to-sp delta in register edx. 240 __ mov(ecx, Operand(esp, kSavedRegistersAreaSize + 1 * kPointerSize)); 241 __ lea(edx, Operand(esp, kSavedRegistersAreaSize + 2 * kPointerSize)); 242 243 __ sub(edx, ebp); 244 __ neg(edx); 245 246 __ push(edi); 247 // Allocate a new deoptimizer object. 248 __ PrepareCallCFunction(6, eax); 249 __ mov(eax, Immediate(0)); 250 Label context_check; 251 __ mov(edi, Operand(ebp, CommonFrameConstants::kContextOrFrameTypeOffset)); 252 __ JumpIfSmi(edi, &context_check); 253 __ mov(eax, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset)); 254 __ bind(&context_check); 255 __ mov(Operand(esp, 0 * kPointerSize), eax); // Function. 256 __ mov(Operand(esp, 1 * kPointerSize), Immediate(type())); // Bailout type. 257 __ mov(Operand(esp, 2 * kPointerSize), ebx); // Bailout id. 258 __ mov(Operand(esp, 3 * kPointerSize), ecx); // Code address or 0. 259 __ mov(Operand(esp, 4 * kPointerSize), edx); // Fp-to-sp delta. 260 __ mov(Operand(esp, 5 * kPointerSize), 261 Immediate(ExternalReference::isolate_address(isolate()))); 262 { 263 AllowExternalCallThatCantCauseGC scope(masm()); 264 __ CallCFunction(ExternalReference::new_deoptimizer_function(isolate()), 6); 265 } 266 267 __ pop(edi); 268 269 // Preserve deoptimizer object in register eax and get the input 270 // frame descriptor pointer. 271 __ mov(ebx, Operand(eax, Deoptimizer::input_offset())); 272 273 // Fill in the input registers. 274 for (int i = kNumberOfRegisters - 1; i >= 0; i--) { 275 int offset = (i * kPointerSize) + FrameDescription::registers_offset(); 276 __ pop(Operand(ebx, offset)); 277 } 278 279 int double_regs_offset = FrameDescription::double_registers_offset(); 280 const RegisterConfiguration* config = RegisterConfiguration::Crankshaft(); 281 // Fill in the double input registers. 282 for (int i = 0; i < X87Register::kMaxNumAllocatableRegisters; ++i) { 283 int code = config->GetAllocatableDoubleCode(i); 284 int dst_offset = code * kDoubleSize + double_regs_offset; 285 int src_offset = code * kDoubleSize; 286 __ fld_d(Operand(esp, src_offset)); 287 __ fstp_d(Operand(ebx, dst_offset)); 288 } 289 290 // Clear FPU all exceptions. 291 // TODO(ulan): Find out why the TOP register is not zero here in some cases, 292 // and check that the generated code never deoptimizes with unbalanced stack. 293 __ fnclex(); 294 295 // Remove the bailout id, return address and the double registers. 296 __ add(esp, Immediate(kDoubleRegsSize + 2 * kPointerSize)); 297 298 // Compute a pointer to the unwinding limit in register ecx; that is 299 // the first stack slot not part of the input frame. 300 __ mov(ecx, Operand(ebx, FrameDescription::frame_size_offset())); 301 __ add(ecx, esp); 302 303 // Unwind the stack down to - but not including - the unwinding 304 // limit and copy the contents of the activation frame to the input 305 // frame description. 306 __ lea(edx, Operand(ebx, FrameDescription::frame_content_offset())); 307 Label pop_loop_header; 308 __ jmp(&pop_loop_header); 309 Label pop_loop; 310 __ bind(&pop_loop); 311 __ pop(Operand(edx, 0)); 312 __ add(edx, Immediate(sizeof(uint32_t))); 313 __ bind(&pop_loop_header); 314 __ cmp(ecx, esp); 315 __ j(not_equal, &pop_loop); 316 317 // Compute the output frame in the deoptimizer. 318 __ push(edi); 319 __ push(eax); 320 __ PrepareCallCFunction(1, ebx); 321 __ mov(Operand(esp, 0 * kPointerSize), eax); 322 { 323 AllowExternalCallThatCantCauseGC scope(masm()); 324 __ CallCFunction( 325 ExternalReference::compute_output_frames_function(isolate()), 1); 326 } 327 __ pop(eax); 328 __ pop(edi); 329 __ mov(esp, Operand(eax, Deoptimizer::caller_frame_top_offset())); 330 331 // Replace the current (input) frame with the output frames. 332 Label outer_push_loop, inner_push_loop, 333 outer_loop_header, inner_loop_header; 334 // Outer loop state: eax = current FrameDescription**, edx = one past the 335 // last FrameDescription**. 336 __ mov(edx, Operand(eax, Deoptimizer::output_count_offset())); 337 __ mov(eax, Operand(eax, Deoptimizer::output_offset())); 338 __ lea(edx, Operand(eax, edx, times_4, 0)); 339 __ jmp(&outer_loop_header); 340 __ bind(&outer_push_loop); 341 // Inner loop state: ebx = current FrameDescription*, ecx = loop index. 342 __ mov(ebx, Operand(eax, 0)); 343 __ mov(ecx, Operand(ebx, FrameDescription::frame_size_offset())); 344 __ jmp(&inner_loop_header); 345 __ bind(&inner_push_loop); 346 __ sub(ecx, Immediate(sizeof(uint32_t))); 347 __ push(Operand(ebx, ecx, times_1, FrameDescription::frame_content_offset())); 348 __ bind(&inner_loop_header); 349 __ test(ecx, ecx); 350 __ j(not_zero, &inner_push_loop); 351 __ add(eax, Immediate(kPointerSize)); 352 __ bind(&outer_loop_header); 353 __ cmp(eax, edx); 354 __ j(below, &outer_push_loop); 355 356 357 // In case of a failed STUB, we have to restore the x87 stack. 358 // x87 stack layout is in edi. 359 Label loop2, done2; 360 // Get the x87 stack depth, the first 3 bits. 361 __ mov(ecx, edi); 362 __ and_(ecx, 0x7); 363 __ j(zero, &done2, Label::kNear); 364 365 __ lea(ecx, Operand(ecx, ecx, times_2, 0)); 366 __ bind(&loop2); 367 __ mov(eax, edi); 368 __ shr_cl(eax); 369 __ and_(eax, 0x7); 370 __ fld_d(Operand(ebx, eax, times_8, double_regs_offset)); 371 __ sub(ecx, Immediate(0x3)); 372 __ j(not_zero, &loop2, Label::kNear); 373 __ bind(&done2); 374 375 // Push state, pc, and continuation from the last output frame. 376 __ push(Operand(ebx, FrameDescription::state_offset())); 377 __ push(Operand(ebx, FrameDescription::pc_offset())); 378 __ push(Operand(ebx, FrameDescription::continuation_offset())); 379 380 381 // Push the registers from the last output frame. 382 for (int i = 0; i < kNumberOfRegisters; i++) { 383 int offset = (i * kPointerSize) + FrameDescription::registers_offset(); 384 __ push(Operand(ebx, offset)); 385 } 386 387 // Restore the registers from the stack. 388 __ popad(); 389 390 // Return to the continuation point. 391 __ ret(0); 392 } 393 394 395 void Deoptimizer::TableEntryGenerator::GeneratePrologue() { 396 // Create a sequence of deoptimization entries. 397 Label done; 398 for (int i = 0; i < count(); i++) { 399 int start = masm()->pc_offset(); 400 USE(start); 401 __ push_imm32(i); 402 __ jmp(&done); 403 DCHECK(masm()->pc_offset() - start == table_entry_size_); 404 } 405 __ bind(&done); 406 } 407 408 409 void FrameDescription::SetCallerPc(unsigned offset, intptr_t value) { 410 SetFrameSlot(offset, value); 411 } 412 413 414 void FrameDescription::SetCallerFp(unsigned offset, intptr_t value) { 415 SetFrameSlot(offset, value); 416 } 417 418 419 void FrameDescription::SetCallerConstantPool(unsigned offset, intptr_t value) { 420 // No embedded constant pool support. 421 UNREACHABLE(); 422 } 423 424 425 #undef __ 426 427 428 } // namespace internal 429 } // namespace v8 430 431 #endif // V8_TARGET_ARCH_X87 432