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.
9 #include "src/codegen.h"
10 #include "src/deoptimizer.h"
11 #include "src/full-codegen.h"
12 #include "src/safepoint-table.h"
17 const int Deoptimizer::table_entry_size_ = 10;
20 int Deoptimizer::patch_size() {
21 return Assembler::kCallInstructionLength;
25 void Deoptimizer::EnsureRelocSpaceForLazyDeoptimization(Handle<Code> code) {
26 Isolate* isolate = code->GetIsolate();
27 HandleScope scope(isolate);
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
43 if (pc_delta <= RelocInfo::kMaxSmallPCDelta) {
48 prev_pc_offset = pc_offset;
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;
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) {
81 byte* pos_before = reloc_info_writer.pos();
83 reloc_info_writer.Write(&rinfo);
84 DCHECK(RelocInfo::kMinRelocCommentSize ==
85 pos_before - reloc_info_writer.pos());
87 // Replace relocation information on the code object.
88 code->set_relocation_info(*new_reloc);
93 void Deoptimizer::PatchCodeForDeoptimization(Isolate* isolate, Code* code) {
94 Address code_start_address = code->instruction_start();
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;
102 pointer = code->instruction_start();
104 CodePatcher patcher(pointer, 1);
105 patcher.masm()->int3();
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();
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);
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).
128 // Emit call to lazy deoptimization at all lazy deopt points.
129 DeoptimizationInputData* deopt_data =
130 DeoptimizationInputData::cast(code->deoptimization_data());
132 Address prev_call_address = NULL;
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),
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());
155 prev_call_address = call_address;
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);
163 // The relocation info is in place, update the size.
164 reloc_info->set_length(new_reloc_size);
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);
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.
180 for (int i = 0; i < Register::kNumRegisters; i++) {
181 input_->SetRegister(i, i * 4);
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);
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));
196 void Deoptimizer::SetPlatformCompiledStubRegisters(
197 FrameDescription* output_frame, CodeStubDescriptor* descriptor) {
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);
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);
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 -
222 DCHECK(JavaScriptFrameConstants::kDynamicAlignmentStateOffset ==
223 JavaScriptFrameConstants::kLocal0Offset);
224 int32_t alignment_state = input_->GetFrameSlot(alignment_state_offset);
225 return (alignment_state == kAlignmentPaddingPushed);
231 void Deoptimizer::EntryGenerator::Generate() {
234 // Save all general purpose registers before messing with them.
235 const int kNumberOfRegisters = Register::kNumRegisters;
237 const int kDoubleRegsSize =
238 kDoubleSize * X87Register::kMaxNumAllocatableRegisters;
240 // Reserve space for x87 fp registers.
241 __ sub(esp, Immediate(kDoubleRegsSize));
245 ExternalReference c_entry_fp_address(Isolate::kCEntryFPAddress, isolate());
246 __ mov(Operand::StaticVariable(c_entry_fp_address), ebp);
248 // GP registers are safe to use now.
249 // Save used x87 fp registers in correct position of previous reserve space.
251 // Get the layout of x87 stack.
252 __ sub(esp, Immediate(kPointerSize));
253 __ fistp_s(MemOperand(esp, 0));
255 // Preserve stack layout in edi
257 // Get the x87 stack depth, the first 3 bits.
260 __ j(zero, &done, Label::kNear);
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);
273 const int kSavedRegistersAreaSize =
274 kNumberOfRegisters * kPointerSize + kDoubleRegsSize;
276 // Get the bailout id from the stack.
277 __ mov(ebx, Operand(esp, kSavedRegistersAreaSize));
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));
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())));
299 AllowExternalCallThatCantCauseGC scope(masm());
300 __ CallCFunction(ExternalReference::new_deoptimizer_function(isolate()), 6);
305 // Preserve deoptimizer object in register eax and get the input
306 // frame descriptor pointer.
307 __ mov(ebx, Operand(eax, Deoptimizer::input_offset()));
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));
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));
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.
329 // Remove the bailout id, return address and the double registers.
330 __ add(esp, Immediate(kDoubleRegsSize + 2 * kPointerSize));
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()));
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);
345 __ pop(Operand(edx, 0));
346 __ add(edx, Immediate(sizeof(uint32_t)));
347 __ bind(&pop_loop_header);
349 __ j(not_equal, &pop_loop);
351 // Compute the output frame in the deoptimizer.
354 __ PrepareCallCFunction(1, ebx);
355 __ mov(Operand(esp, 0 * kPointerSize), eax);
357 AllowExternalCallThatCantCauseGC scope(masm());
359 ExternalReference::compute_output_frames_function(isolate()), 1);
364 // If frame was dynamically aligned, pop padding.
366 __ cmp(Operand(eax, Deoptimizer::has_alignment_padding_offset()),
368 __ j(equal, &no_padding);
370 if (FLAG_debug_code) {
371 __ cmp(ecx, Immediate(kAlignmentZapValue));
372 __ Assert(equal, kAlignmentMarkerExpected);
374 __ bind(&no_padding);
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);
395 __ j(not_zero, &inner_push_loop);
396 __ add(eax, Immediate(kPointerSize));
397 __ bind(&outer_loop_header);
399 __ j(below, &outer_push_loop);
402 // In case of a failed STUB, we have to restore the x87 stack.
403 // x87 stack layout is in edi.
405 // Get the x87 stack depth, the first 3 bits.
408 __ j(zero, &done2, Label::kNear);
410 __ lea(ecx, Operand(ecx, ecx, times_2, 0));
415 __ fld_d(Operand(ebx, eax, times_8, double_regs_offset));
416 __ sub(ecx, Immediate(0x3));
417 __ j(not_zero, &loop2, Label::kNear);
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()));
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));
432 // Restore the registers from the stack.
435 // Return to the continuation point.
440 void Deoptimizer::TableEntryGenerator::GeneratePrologue() {
441 // Create a sequence of deoptimization entries.
443 for (int i = 0; i < count(); i++) {
444 int start = masm()->pc_offset();
448 DCHECK(masm()->pc_offset() - start == table_entry_size_);
454 void FrameDescription::SetCallerPc(unsigned offset, intptr_t value) {
455 SetFrameSlot(offset, value);
459 void FrameDescription::SetCallerFp(unsigned offset, intptr_t value) {
460 SetFrameSlot(offset, value);
464 void FrameDescription::SetCallerConstantPool(unsigned offset, intptr_t value) {
465 // No out-of-line constant pool support.
473 } } // namespace v8::internal
475 #endif // V8_TARGET_ARCH_X87