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