deps/v8/src/x87/deoptimizer-x87.cc

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