src/ia32/deoptimizer-ia32.cc - platform/external/v8 - Git at Google

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "src/v8.h"

 #if V8_TARGET_ARCH_IA32

 #include "src/codegen.h"
 #include "src/deoptimizer.h"
 #include "src/full-codegen.h"
 #include "src/safepoint-table.h"

 namespace v8 {
 namespace internal {

 const int Deoptimizer::table_entry_size_ = 10;


 int Deoptimizer::patch_size() {
   return Assembler::kCallInstructionLength;
 }


 void Deoptimizer::EnsureRelocSpaceForLazyDeoptimization(Handle<Code> code) {
   Isolate* isolate = code->GetIsolate();
   HandleScope scope(isolate);

   // Compute the size of relocation information needed for the code
   // patching in Deoptimizer::PatchCodeForDeoptimization below.
   int min_reloc_size = 0;
   int prev_pc_offset = 0;
   DeoptimizationInputData* deopt_data =
       DeoptimizationInputData::cast(code->deoptimization_data());
   for (int i = 0; i < deopt_data->DeoptCount(); i++) {
     int pc_offset = deopt_data->Pc(i)->value();
     if (pc_offset == -1) continue;
     DCHECK_GE(pc_offset, prev_pc_offset);
     int pc_delta = pc_offset - prev_pc_offset;
     // We use RUNTIME_ENTRY reloc info which has a size of 2 bytes
     // if encodable with small pc delta encoding and up to 6 bytes
     // otherwise.
     if (pc_delta <= RelocInfo::kMaxSmallPCDelta) {
       min_reloc_size += 2;
     } else {
       min_reloc_size += 6;
     }
     prev_pc_offset = pc_offset;
   }

   // If the relocation information is not big enough we create a new
   // relocation info object that is padded with comments to make it
   // big enough for lazy doptimization.
   int reloc_length = code->relocation_info()->length();
   if (min_reloc_size > reloc_length) {
     int comment_reloc_size = RelocInfo::kMinRelocCommentSize;
     // Padding needed.
     int min_padding = min_reloc_size - reloc_length;
     // Number of comments needed to take up at least that much space.
     int additional_comments =
         (min_padding + comment_reloc_size - 1) / comment_reloc_size;
     // Actual padding size.
     int padding = additional_comments * comment_reloc_size;
     // Allocate new relocation info and copy old relocation to the end
     // of the new relocation info array because relocation info is
     // written and read backwards.
     Factory* factory = isolate->factory();
     Handle<ByteArray> new_reloc =
         factory->NewByteArray(reloc_length + padding, TENURED);
     MemCopy(new_reloc->GetDataStartAddress() + padding,
             code->relocation_info()->GetDataStartAddress(), reloc_length);
     // Create a relocation writer to write the comments in the padding
     // space. Use position 0 for everything to ensure short encoding.
     RelocInfoWriter reloc_info_writer(
         new_reloc->GetDataStartAddress() + padding, 0);
     intptr_t comment_string
         = reinterpret_cast<intptr_t>(RelocInfo::kFillerCommentString);
     RelocInfo rinfo(0, RelocInfo::COMMENT, comment_string, NULL);
     for (int i = 0; i < additional_comments; ++i) {
 #ifdef DEBUG
       byte* pos_before = reloc_info_writer.pos();
 #endif
       reloc_info_writer.Write(&rinfo);
       DCHECK(RelocInfo::kMinRelocCommentSize ==
              pos_before - reloc_info_writer.pos());
     }
     // Replace relocation information on the code object.
     code->set_relocation_info(*new_reloc);
   }
 }


 void Deoptimizer::PatchCodeForDeoptimization(Isolate* isolate, Code* code) {
   Address code_start_address = code->instruction_start();

   if (FLAG_zap_code_space) {
     // Fail hard and early if we enter this code object again.
     byte* pointer = code->FindCodeAgeSequence();
     if (pointer != NULL) {
       pointer += kNoCodeAgeSequenceLength;
     } else {
       pointer = code->instruction_start();
     }
     CodePatcher patcher(pointer, 1);
     patcher.masm()->int3();

     DeoptimizationInputData* data =
         DeoptimizationInputData::cast(code->deoptimization_data());
     int osr_offset = data->OsrPcOffset()->value();
     if (osr_offset > 0) {
       CodePatcher osr_patcher(code->instruction_start() + osr_offset, 1);
       osr_patcher.masm()->int3();
     }
   }

   // We will overwrite the code's relocation info in-place. Relocation info
   // is written backward. The relocation info is the payload of a byte
   // array.  Later on we will slide this to the start of the byte array and
   // create a filler object in the remaining space.
   ByteArray* reloc_info = code->relocation_info();
   Address reloc_end_address = reloc_info->address() + reloc_info->Size();
   RelocInfoWriter reloc_info_writer(reloc_end_address, code_start_address);

   // Since the call is a relative encoding, write new
   // reloc info.  We do not need any of the existing reloc info because the
   // existing code will not be used again (we zap it in debug builds).
   //
   // Emit call to lazy deoptimization at all lazy deopt points.
   DeoptimizationInputData* deopt_data =
       DeoptimizationInputData::cast(code->deoptimization_data());
 #ifdef DEBUG
   Address prev_call_address = NULL;
 #endif
   // For each LLazyBailout instruction insert a call to the corresponding
   // deoptimization entry.
   for (int i = 0; i < deopt_data->DeoptCount(); i++) {
     if (deopt_data->Pc(i)->value() == -1) continue;
     // Patch lazy deoptimization entry.
     Address call_address = code_start_address + deopt_data->Pc(i)->value();
     CodePatcher patcher(call_address, patch_size());
     Address deopt_entry = GetDeoptimizationEntry(isolate, i, LAZY);
     patcher.masm()->call(deopt_entry, RelocInfo::NONE32);
     // We use RUNTIME_ENTRY for deoptimization bailouts.
     RelocInfo rinfo(call_address + 1,  // 1 after the call opcode.
                     RelocInfo::RUNTIME_ENTRY,
                     reinterpret_cast<intptr_t>(deopt_entry),
                     NULL);
     reloc_info_writer.Write(&rinfo);
     DCHECK_GE(reloc_info_writer.pos(),
               reloc_info->address() + ByteArray::kHeaderSize);
     DCHECK(prev_call_address == NULL ||
            call_address >= prev_call_address + patch_size());
     DCHECK(call_address + patch_size() <= code->instruction_end());
 #ifdef DEBUG
     prev_call_address = call_address;
 #endif
   }

   // Move the relocation info to the beginning of the byte array.
   int new_reloc_size = reloc_end_address - reloc_info_writer.pos();
   MemMove(code->relocation_start(), reloc_info_writer.pos(), new_reloc_size);

   // The relocation info is in place, update the size.
   reloc_info->set_length(new_reloc_size);

   // Handle the junk part after the new relocation info. We will create
   // a non-live object in the extra space at the end of the former reloc info.
   Address junk_address = reloc_info->address() + reloc_info->Size();
   DCHECK(junk_address <= reloc_end_address);
   isolate->heap()->CreateFillerObjectAt(junk_address,
                                         reloc_end_address - junk_address);
 }


 void Deoptimizer::FillInputFrame(Address tos, JavaScriptFrame* frame) {
   // Set the register values. The values are not important as there are no
   // callee saved registers in JavaScript frames, so all registers are
   // spilled. Registers ebp and esp are set to the correct values though.

   for (int i = 0; i < Register::kNumRegisters; i++) {
     input_->SetRegister(i, i * 4);
   }
   input_->SetRegister(esp.code(), reinterpret_cast<intptr_t>(frame->sp()));
   input_->SetRegister(ebp.code(), reinterpret_cast<intptr_t>(frame->fp()));
   for (int i = 0; i < XMMRegister::kMaxNumAllocatableRegisters; i++) {
     input_->SetDoubleRegister(i, 0.0);
   }

   // Fill the frame content from the actual data on the frame.
   for (unsigned i = 0; i < input_->GetFrameSize(); i += kPointerSize) {
     input_->SetFrameSlot(i, Memory::uint32_at(tos + i));
   }
 }


 void Deoptimizer::SetPlatformCompiledStubRegisters(
     FrameDescription* output_frame, CodeStubDescriptor* descriptor) {
   intptr_t handler =
       reinterpret_cast<intptr_t>(descriptor->deoptimization_handler());
   int params = descriptor->GetHandlerParameterCount();
   output_frame->SetRegister(eax.code(), params);
   output_frame->SetRegister(ebx.code(), handler);
 }


 void Deoptimizer::CopyDoubleRegisters(FrameDescription* output_frame) {
   for (int i = 0; i < XMMRegister::kMaxNumAllocatableRegisters; ++i) {
     double double_value = input_->GetDoubleRegister(i);
     output_frame->SetDoubleRegister(i, double_value);
   }
 }


 bool Deoptimizer::HasAlignmentPadding(JSFunction* function) {
   int parameter_count = function->shared()->formal_parameter_count() + 1;
   unsigned input_frame_size = input_->GetFrameSize();
   unsigned alignment_state_offset =
       input_frame_size - parameter_count * kPointerSize -
       StandardFrameConstants::kFixedFrameSize -
       kPointerSize;
   DCHECK(JavaScriptFrameConstants::kDynamicAlignmentStateOffset ==
       JavaScriptFrameConstants::kLocal0Offset);
   int32_t alignment_state = input_->GetFrameSlot(alignment_state_offset);
   return (alignment_state == kAlignmentPaddingPushed);
 }


 #define __ masm()->

 void Deoptimizer::EntryGenerator::Generate() {
   GeneratePrologue();

   // Save all general purpose registers before messing with them.
   const int kNumberOfRegisters = Register::kNumRegisters;

   const int kDoubleRegsSize = kDoubleSize *
                               XMMRegister::kMaxNumAllocatableRegisters;
   __ sub(esp, Immediate(kDoubleRegsSize));
   for (int i = 0; i < XMMRegister::kMaxNumAllocatableRegisters; ++i) {
     XMMRegister xmm_reg = XMMRegister::FromAllocationIndex(i);
     int offset = i * kDoubleSize;
     __ movsd(Operand(esp, offset), xmm_reg);
   }

   __ pushad();

   const int kSavedRegistersAreaSize = kNumberOfRegisters * kPointerSize +
                                       kDoubleRegsSize;

   // Get the bailout id from the stack.
   __ mov(ebx, Operand(esp, kSavedRegistersAreaSize));

   // Get the address of the location in the code object
   // and compute the fp-to-sp delta in register edx.
   __ mov(ecx, Operand(esp, kSavedRegistersAreaSize + 1 * kPointerSize));
   __ lea(edx, Operand(esp, kSavedRegistersAreaSize + 2 * kPointerSize));

   __ sub(edx, ebp);
   __ neg(edx);

   // Allocate a new deoptimizer object.
   __ PrepareCallCFunction(6, eax);
   __ mov(eax, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
   __ mov(Operand(esp, 0 * kPointerSize), eax);  // Function.
   __ mov(Operand(esp, 1 * kPointerSize), Immediate(type()));  // Bailout type.
   __ mov(Operand(esp, 2 * kPointerSize), ebx);  // Bailout id.
   __ mov(Operand(esp, 3 * kPointerSize), ecx);  // Code address or 0.
   __ mov(Operand(esp, 4 * kPointerSize), edx);  // Fp-to-sp delta.
   __ mov(Operand(esp, 5 * kPointerSize),
          Immediate(ExternalReference::isolate_address(isolate())));
   {
     AllowExternalCallThatCantCauseGC scope(masm());
     __ CallCFunction(ExternalReference::new_deoptimizer_function(isolate()), 6);
   }

   // Preserve deoptimizer object in register eax and get the input
   // frame descriptor pointer.
   __ mov(ebx, Operand(eax, Deoptimizer::input_offset()));

   // Fill in the input registers.
   for (int i = kNumberOfRegisters - 1; i >= 0; i--) {
     int offset = (i * kPointerSize) + FrameDescription::registers_offset();
     __ pop(Operand(ebx, offset));
   }

   int double_regs_offset = FrameDescription::double_registers_offset();
   // Fill in the double input registers.
   for (int i = 0; i < XMMRegister::kMaxNumAllocatableRegisters; ++i) {
     int dst_offset = i * kDoubleSize + double_regs_offset;
     int src_offset = i * kDoubleSize;
     __ movsd(xmm0, Operand(esp, src_offset));
     __ movsd(Operand(ebx, dst_offset), xmm0);
   }

   // Clear FPU all exceptions.
   // TODO(ulan): Find out why the TOP register is not zero here in some cases,
   // and check that the generated code never deoptimizes with unbalanced stack.
   __ fnclex();

   // Remove the bailout id, return address and the double registers.
   __ add(esp, Immediate(kDoubleRegsSize + 2 * kPointerSize));

   // Compute a pointer to the unwinding limit in register ecx; that is
   // the first stack slot not part of the input frame.
   __ mov(ecx, Operand(ebx, FrameDescription::frame_size_offset()));
   __ add(ecx, esp);

   // Unwind the stack down to - but not including - the unwinding
   // limit and copy the contents of the activation frame to the input
   // frame description.
   __ lea(edx, Operand(ebx, FrameDescription::frame_content_offset()));
   Label pop_loop_header;
   __ jmp(&pop_loop_header);
   Label pop_loop;
   __ bind(&pop_loop);
   __ pop(Operand(edx, 0));
   __ add(edx, Immediate(sizeof(uint32_t)));
   __ bind(&pop_loop_header);
   __ cmp(ecx, esp);
   __ j(not_equal, &pop_loop);

   // Compute the output frame in the deoptimizer.
   __ push(eax);
   __ PrepareCallCFunction(1, ebx);
   __ mov(Operand(esp, 0 * kPointerSize), eax);
   {
     AllowExternalCallThatCantCauseGC scope(masm());
     __ CallCFunction(
         ExternalReference::compute_output_frames_function(isolate()), 1);
   }
   __ pop(eax);

   // If frame was dynamically aligned, pop padding.
   Label no_padding;
   __ cmp(Operand(eax, Deoptimizer::has_alignment_padding_offset()),
          Immediate(0));
   __ j(equal, &no_padding);
   __ pop(ecx);
   if (FLAG_debug_code) {
     __ cmp(ecx, Immediate(kAlignmentZapValue));
     __ Assert(equal, kAlignmentMarkerExpected);
   }
   __ bind(&no_padding);

   // Replace the current frame with the output frames.
   Label outer_push_loop, inner_push_loop,
       outer_loop_header, inner_loop_header;
   // Outer loop state: eax = current FrameDescription**, edx = one past the
   // last FrameDescription**.
   __ mov(edx, Operand(eax, Deoptimizer::output_count_offset()));
   __ mov(eax, Operand(eax, Deoptimizer::output_offset()));
   __ lea(edx, Operand(eax, edx, times_4, 0));
   __ jmp(&outer_loop_header);
   __ bind(&outer_push_loop);
   // Inner loop state: ebx = current FrameDescription*, ecx = loop index.
   __ mov(ebx, Operand(eax, 0));
   __ mov(ecx, Operand(ebx, FrameDescription::frame_size_offset()));
   __ jmp(&inner_loop_header);
   __ bind(&inner_push_loop);
   __ sub(ecx, Immediate(sizeof(uint32_t)));
   __ push(Operand(ebx, ecx, times_1, FrameDescription::frame_content_offset()));
   __ bind(&inner_loop_header);
   __ test(ecx, ecx);
   __ j(not_zero, &inner_push_loop);
   __ add(eax, Immediate(kPointerSize));
   __ bind(&outer_loop_header);
   __ cmp(eax, edx);
   __ j(below, &outer_push_loop);

   // In case of a failed STUB, we have to restore the XMM registers.
   for (int i = 0; i < XMMRegister::kMaxNumAllocatableRegisters; ++i) {
     XMMRegister xmm_reg = XMMRegister::FromAllocationIndex(i);
     int src_offset = i * kDoubleSize + double_regs_offset;
     __ movsd(xmm_reg, Operand(ebx, src_offset));
   }

   // Push state, pc, and continuation from the last output frame.
   __ push(Operand(ebx, FrameDescription::state_offset()));
   __ push(Operand(ebx, FrameDescription::pc_offset()));
   __ push(Operand(ebx, FrameDescription::continuation_offset()));


   // Push the registers from the last output frame.
   for (int i = 0; i < kNumberOfRegisters; i++) {
     int offset = (i * kPointerSize) + FrameDescription::registers_offset();
     __ push(Operand(ebx, offset));
   }

   // Restore the registers from the stack.
   __ popad();

   // Return to the continuation point.
   __ ret(0);
 }


 void Deoptimizer::TableEntryGenerator::GeneratePrologue() {
   // Create a sequence of deoptimization entries.
   Label done;
   for (int i = 0; i < count(); i++) {
     int start = masm()->pc_offset();
     USE(start);
     __ push_imm32(i);
     __ jmp(&done);
     DCHECK(masm()->pc_offset() - start == table_entry_size_);
   }
   __ bind(&done);
 }


 void FrameDescription::SetCallerPc(unsigned offset, intptr_t value) {
   SetFrameSlot(offset, value);
 }


 void FrameDescription::SetCallerFp(unsigned offset, intptr_t value) {
   SetFrameSlot(offset, value);
 }


 void FrameDescription::SetCallerConstantPool(unsigned offset, intptr_t value) {
   // No out-of-line constant pool support.
   UNREACHABLE();
 }


 #undef __


 } }  // namespace v8::internal

 #endif  // V8_TARGET_ARCH_IA32
	// Copyright 2012 the V8 project authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "src/v8.h"

	#if V8_TARGET_ARCH_IA32

	#include "src/codegen.h"
	#include "src/deoptimizer.h"
	#include "src/full-codegen.h"
	#include "src/safepoint-table.h"

	namespace v8 {
	namespace internal {

	const int Deoptimizer::table_entry_size_ = 10;


	int Deoptimizer::patch_size() {
	return Assembler::kCallInstructionLength;
	}


	void Deoptimizer::EnsureRelocSpaceForLazyDeoptimization(Handle<Code> code) {
	Isolate* isolate = code->GetIsolate();
	HandleScope scope(isolate);

	// Compute the size of relocation information needed for the code
	// patching in Deoptimizer::PatchCodeForDeoptimization below.
	int min_reloc_size = 0;
	int prev_pc_offset = 0;
	DeoptimizationInputData* deopt_data =
	DeoptimizationInputData::cast(code->deoptimization_data());
	for (int i = 0; i < deopt_data->DeoptCount(); i++) {
	int pc_offset = deopt_data->Pc(i)->value();
	if (pc_offset == -1) continue;
	DCHECK_GE(pc_offset, prev_pc_offset);
	int pc_delta = pc_offset - prev_pc_offset;
	// We use RUNTIME_ENTRY reloc info which has a size of 2 bytes
	// if encodable with small pc delta encoding and up to 6 bytes
	// otherwise.
	if (pc_delta <= RelocInfo::kMaxSmallPCDelta) {
	min_reloc_size += 2;
	} else {
	min_reloc_size += 6;
	}
	prev_pc_offset = pc_offset;
	}

	// If the relocation information is not big enough we create a new
	// relocation info object that is padded with comments to make it
	// big enough for lazy doptimization.
	int reloc_length = code->relocation_info()->length();
	if (min_reloc_size > reloc_length) {
	int comment_reloc_size = RelocInfo::kMinRelocCommentSize;
	// Padding needed.
	int min_padding = min_reloc_size - reloc_length;
	// Number of comments needed to take up at least that much space.
	int additional_comments =
	(min_padding + comment_reloc_size - 1) / comment_reloc_size;
	// Actual padding size.
	int padding = additional_comments * comment_reloc_size;
	// Allocate new relocation info and copy old relocation to the end
	// of the new relocation info array because relocation info is
	// written and read backwards.
	Factory* factory = isolate->factory();
	Handle<ByteArray> new_reloc =
	factory->NewByteArray(reloc_length + padding, TENURED);
	MemCopy(new_reloc->GetDataStartAddress() + padding,
	code->relocation_info()->GetDataStartAddress(), reloc_length);
	// Create a relocation writer to write the comments in the padding
	// space. Use position 0 for everything to ensure short encoding.
	RelocInfoWriter reloc_info_writer(
	new_reloc->GetDataStartAddress() + padding, 0);
	intptr_t comment_string
	= reinterpret_cast<intptr_t>(RelocInfo::kFillerCommentString);
	RelocInfo rinfo(0, RelocInfo::COMMENT, comment_string, NULL);
	for (int i = 0; i < additional_comments; ++i) {
	#ifdef DEBUG
	byte* pos_before = reloc_info_writer.pos();
	#endif
	reloc_info_writer.Write(&rinfo);
	DCHECK(RelocInfo::kMinRelocCommentSize ==
	pos_before - reloc_info_writer.pos());
	}
	// Replace relocation information on the code object.
	code->set_relocation_info(*new_reloc);
	}
	}


	void Deoptimizer::PatchCodeForDeoptimization(Isolate* isolate, Code* code) {
	Address code_start_address = code->instruction_start();

	if (FLAG_zap_code_space) {
	// Fail hard and early if we enter this code object again.
	byte* pointer = code->FindCodeAgeSequence();
	if (pointer != NULL) {
	pointer += kNoCodeAgeSequenceLength;
	} else {
	pointer = code->instruction_start();
	}
	CodePatcher patcher(pointer, 1);
	patcher.masm()->int3();

	DeoptimizationInputData* data =
	DeoptimizationInputData::cast(code->deoptimization_data());
	int osr_offset = data->OsrPcOffset()->value();
	if (osr_offset > 0) {
	CodePatcher osr_patcher(code->instruction_start() + osr_offset, 1);
	osr_patcher.masm()->int3();
	}
	}

	// We will overwrite the code's relocation info in-place. Relocation info
	// is written backward. The relocation info is the payload of a byte
	// array. Later on we will slide this to the start of the byte array and
	// create a filler object in the remaining space.
	ByteArray* reloc_info = code->relocation_info();
	Address reloc_end_address = reloc_info->address() + reloc_info->Size();
	RelocInfoWriter reloc_info_writer(reloc_end_address, code_start_address);

	// Since the call is a relative encoding, write new
	// reloc info. We do not need any of the existing reloc info because the
	// existing code will not be used again (we zap it in debug builds).
	//
	// Emit call to lazy deoptimization at all lazy deopt points.
	DeoptimizationInputData* deopt_data =
	DeoptimizationInputData::cast(code->deoptimization_data());
	#ifdef DEBUG
	Address prev_call_address = NULL;
	#endif
	// For each LLazyBailout instruction insert a call to the corresponding
	// deoptimization entry.
	for (int i = 0; i < deopt_data->DeoptCount(); i++) {
	if (deopt_data->Pc(i)->value() == -1) continue;
	// Patch lazy deoptimization entry.
	Address call_address = code_start_address + deopt_data->Pc(i)->value();
	CodePatcher patcher(call_address, patch_size());
	Address deopt_entry = GetDeoptimizationEntry(isolate, i, LAZY);
	patcher.masm()->call(deopt_entry, RelocInfo::NONE32);
	// We use RUNTIME_ENTRY for deoptimization bailouts.
	RelocInfo rinfo(call_address + 1, // 1 after the call opcode.
	RelocInfo::RUNTIME_ENTRY,
	reinterpret_cast<intptr_t>(deopt_entry),
	NULL);
	reloc_info_writer.Write(&rinfo);
	DCHECK_GE(reloc_info_writer.pos(),
	reloc_info->address() + ByteArray::kHeaderSize);
	DCHECK(prev_call_address == NULL \|\|
	call_address >= prev_call_address + patch_size());
	DCHECK(call_address + patch_size() <= code->instruction_end());
	#ifdef DEBUG
	prev_call_address = call_address;
	#endif
	}

	// Move the relocation info to the beginning of the byte array.
	int new_reloc_size = reloc_end_address - reloc_info_writer.pos();
	MemMove(code->relocation_start(), reloc_info_writer.pos(), new_reloc_size);

	// The relocation info is in place, update the size.
	reloc_info->set_length(new_reloc_size);

	// Handle the junk part after the new relocation info. We will create
	// a non-live object in the extra space at the end of the former reloc info.
	Address junk_address = reloc_info->address() + reloc_info->Size();
	DCHECK(junk_address <= reloc_end_address);
	isolate->heap()->CreateFillerObjectAt(junk_address,
	reloc_end_address - junk_address);
	}


	void Deoptimizer::FillInputFrame(Address tos, JavaScriptFrame* frame) {
	// Set the register values. The values are not important as there are no
	// callee saved registers in JavaScript frames, so all registers are
	// spilled. Registers ebp and esp are set to the correct values though.

	for (int i = 0; i < Register::kNumRegisters; i++) {
	input_->SetRegister(i, i * 4);
	}
	input_->SetRegister(esp.code(), reinterpret_cast<intptr_t>(frame->sp()));
	input_->SetRegister(ebp.code(), reinterpret_cast<intptr_t>(frame->fp()));
	for (int i = 0; i < XMMRegister::kMaxNumAllocatableRegisters; i++) {
	input_->SetDoubleRegister(i, 0.0);
	}

	// Fill the frame content from the actual data on the frame.
	for (unsigned i = 0; i < input_->GetFrameSize(); i += kPointerSize) {
	input_->SetFrameSlot(i, Memory::uint32_at(tos + i));
	}
	}


	void Deoptimizer::SetPlatformCompiledStubRegisters(
	FrameDescription* output_frame, CodeStubDescriptor* descriptor) {
	intptr_t handler =
	reinterpret_cast<intptr_t>(descriptor->deoptimization_handler());
	int params = descriptor->GetHandlerParameterCount();
	output_frame->SetRegister(eax.code(), params);
	output_frame->SetRegister(ebx.code(), handler);
	}


	void Deoptimizer::CopyDoubleRegisters(FrameDescription* output_frame) {
	for (int i = 0; i < XMMRegister::kMaxNumAllocatableRegisters; ++i) {
	double double_value = input_->GetDoubleRegister(i);
	output_frame->SetDoubleRegister(i, double_value);
	}
	}


	bool Deoptimizer::HasAlignmentPadding(JSFunction* function) {
	int parameter_count = function->shared()->formal_parameter_count() + 1;
	unsigned input_frame_size = input_->GetFrameSize();
	unsigned alignment_state_offset =
	input_frame_size - parameter_count * kPointerSize -
	StandardFrameConstants::kFixedFrameSize -
	kPointerSize;
	DCHECK(JavaScriptFrameConstants::kDynamicAlignmentStateOffset ==
	JavaScriptFrameConstants::kLocal0Offset);
	int32_t alignment_state = input_->GetFrameSlot(alignment_state_offset);
	return (alignment_state == kAlignmentPaddingPushed);
	}


	#define __ masm()->

	void Deoptimizer::EntryGenerator::Generate() {
	GeneratePrologue();

	// Save all general purpose registers before messing with them.
	const int kNumberOfRegisters = Register::kNumRegisters;

	const int kDoubleRegsSize = kDoubleSize *
	XMMRegister::kMaxNumAllocatableRegisters;
	__ sub(esp, Immediate(kDoubleRegsSize));
	for (int i = 0; i < XMMRegister::kMaxNumAllocatableRegisters; ++i) {
	XMMRegister xmm_reg = XMMRegister::FromAllocationIndex(i);
	int offset = i * kDoubleSize;
	__ movsd(Operand(esp, offset), xmm_reg);
	}

	__ pushad();

	const int kSavedRegistersAreaSize = kNumberOfRegisters * kPointerSize +
	kDoubleRegsSize;

	// Get the bailout id from the stack.
	__ mov(ebx, Operand(esp, kSavedRegistersAreaSize));

	// Get the address of the location in the code object
	// and compute the fp-to-sp delta in register edx.
	__ mov(ecx, Operand(esp, kSavedRegistersAreaSize + 1 * kPointerSize));
	__ lea(edx, Operand(esp, kSavedRegistersAreaSize + 2 * kPointerSize));

	__ sub(edx, ebp);
	__ neg(edx);

	// Allocate a new deoptimizer object.
	__ PrepareCallCFunction(6, eax);
	__ mov(eax, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
	__ mov(Operand(esp, 0 * kPointerSize), eax); // Function.
	__ mov(Operand(esp, 1 * kPointerSize), Immediate(type())); // Bailout type.
	__ mov(Operand(esp, 2 * kPointerSize), ebx); // Bailout id.
	__ mov(Operand(esp, 3 * kPointerSize), ecx); // Code address or 0.
	__ mov(Operand(esp, 4 * kPointerSize), edx); // Fp-to-sp delta.
	__ mov(Operand(esp, 5 * kPointerSize),
	Immediate(ExternalReference::isolate_address(isolate())));
	{
	AllowExternalCallThatCantCauseGC scope(masm());
	__ CallCFunction(ExternalReference::new_deoptimizer_function(isolate()), 6);
	}

	// Preserve deoptimizer object in register eax and get the input
	// frame descriptor pointer.
	__ mov(ebx, Operand(eax, Deoptimizer::input_offset()));

	// Fill in the input registers.
	for (int i = kNumberOfRegisters - 1; i >= 0; i--) {
	int offset = (i * kPointerSize) + FrameDescription::registers_offset();
	__ pop(Operand(ebx, offset));
	}

	int double_regs_offset = FrameDescription::double_registers_offset();
	// Fill in the double input registers.
	for (int i = 0; i < XMMRegister::kMaxNumAllocatableRegisters; ++i) {
	int dst_offset = i * kDoubleSize + double_regs_offset;
	int src_offset = i * kDoubleSize;
	__ movsd(xmm0, Operand(esp, src_offset));
	__ movsd(Operand(ebx, dst_offset), xmm0);
	}

	// Clear FPU all exceptions.
	// TODO(ulan): Find out why the TOP register is not zero here in some cases,
	// and check that the generated code never deoptimizes with unbalanced stack.
	__ fnclex();

	// Remove the bailout id, return address and the double registers.
	__ add(esp, Immediate(kDoubleRegsSize + 2 * kPointerSize));

	// Compute a pointer to the unwinding limit in register ecx; that is
	// the first stack slot not part of the input frame.
	__ mov(ecx, Operand(ebx, FrameDescription::frame_size_offset()));
	__ add(ecx, esp);

	// Unwind the stack down to - but not including - the unwinding
	// limit and copy the contents of the activation frame to the input
	// frame description.
	__ lea(edx, Operand(ebx, FrameDescription::frame_content_offset()));
	Label pop_loop_header;
	__ jmp(&pop_loop_header);
	Label pop_loop;
	__ bind(&pop_loop);
	__ pop(Operand(edx, 0));
	__ add(edx, Immediate(sizeof(uint32_t)));
	__ bind(&pop_loop_header);
	__ cmp(ecx, esp);
	__ j(not_equal, &pop_loop);

	// Compute the output frame in the deoptimizer.
	__ push(eax);
	__ PrepareCallCFunction(1, ebx);
	__ mov(Operand(esp, 0 * kPointerSize), eax);
	{
	AllowExternalCallThatCantCauseGC scope(masm());
	__ CallCFunction(
	ExternalReference::compute_output_frames_function(isolate()), 1);
	}
	__ pop(eax);

	// If frame was dynamically aligned, pop padding.
	Label no_padding;
	__ cmp(Operand(eax, Deoptimizer::has_alignment_padding_offset()),
	Immediate(0));
	__ j(equal, &no_padding);
	__ pop(ecx);
	if (FLAG_debug_code) {
	__ cmp(ecx, Immediate(kAlignmentZapValue));
	__ Assert(equal, kAlignmentMarkerExpected);
	}
	__ bind(&no_padding);

	// Replace the current frame with the output frames.
	Label outer_push_loop, inner_push_loop,
	outer_loop_header, inner_loop_header;
	// Outer loop state: eax = current FrameDescription**, edx = one past the
	// last FrameDescription**.
	__ mov(edx, Operand(eax, Deoptimizer::output_count_offset()));
	__ mov(eax, Operand(eax, Deoptimizer::output_offset()));
	__ lea(edx, Operand(eax, edx, times_4, 0));
	__ jmp(&outer_loop_header);
	__ bind(&outer_push_loop);
	// Inner loop state: ebx = current FrameDescription*, ecx = loop index.
	__ mov(ebx, Operand(eax, 0));
	__ mov(ecx, Operand(ebx, FrameDescription::frame_size_offset()));
	__ jmp(&inner_loop_header);
	__ bind(&inner_push_loop);
	__ sub(ecx, Immediate(sizeof(uint32_t)));
	__ push(Operand(ebx, ecx, times_1, FrameDescription::frame_content_offset()));
	__ bind(&inner_loop_header);
	__ test(ecx, ecx);
	__ j(not_zero, &inner_push_loop);
	__ add(eax, Immediate(kPointerSize));
	__ bind(&outer_loop_header);
	__ cmp(eax, edx);
	__ j(below, &outer_push_loop);

	// In case of a failed STUB, we have to restore the XMM registers.
	for (int i = 0; i < XMMRegister::kMaxNumAllocatableRegisters; ++i) {
	XMMRegister xmm_reg = XMMRegister::FromAllocationIndex(i);
	int src_offset = i * kDoubleSize + double_regs_offset;
	__ movsd(xmm_reg, Operand(ebx, src_offset));
	}

	// Push state, pc, and continuation from the last output frame.
	__ push(Operand(ebx, FrameDescription::state_offset()));
	__ push(Operand(ebx, FrameDescription::pc_offset()));
	__ push(Operand(ebx, FrameDescription::continuation_offset()));


	// Push the registers from the last output frame.
	for (int i = 0; i < kNumberOfRegisters; i++) {
	int offset = (i * kPointerSize) + FrameDescription::registers_offset();
	__ push(Operand(ebx, offset));
	}

	// Restore the registers from the stack.
	__ popad();

	// Return to the continuation point.
	__ ret(0);
	}


	void Deoptimizer::TableEntryGenerator::GeneratePrologue() {
	// Create a sequence of deoptimization entries.
	Label done;
	for (int i = 0; i < count(); i++) {
	int start = masm()->pc_offset();
	USE(start);
	__ push_imm32(i);
	__ jmp(&done);
	DCHECK(masm()->pc_offset() - start == table_entry_size_);
	}
	__ bind(&done);
	}


	void FrameDescription::SetCallerPc(unsigned offset, intptr_t value) {
	SetFrameSlot(offset, value);
	}


	void FrameDescription::SetCallerFp(unsigned offset, intptr_t value) {
	SetFrameSlot(offset, value);
	}


	void FrameDescription::SetCallerConstantPool(unsigned offset, intptr_t value) {
	// No out-of-line constant pool support.
	UNREACHABLE();
	}


	#undef __


	} } // namespace v8::internal

	#endif // V8_TARGET_ARCH_IA32