blob: 9a5aa902b8f383bdf3814545dcdd4a6a2758ba54 [file] [log] [blame]
Steve Block1e0659c2011-05-24 12:43:12 +01001// Copyright 2011 the V8 project authors. All rights reserved.
Ben Murdochb0fe1622011-05-05 13:52:32 +01002// Redistribution and use in source and binary forms, with or without
3// modification, are permitted provided that the following conditions are
4// met:
5//
6// * Redistributions of source code must retain the above copyright
7// notice, this list of conditions and the following disclaimer.
8// * Redistributions in binary form must reproduce the above
9// copyright notice, this list of conditions and the following
10// disclaimer in the documentation and/or other materials provided
11// with the distribution.
12// * Neither the name of Google Inc. nor the names of its
13// contributors may be used to endorse or promote products derived
14// from this software without specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28#include "v8.h"
29
30#include "codegen.h"
31#include "deoptimizer.h"
32#include "full-codegen.h"
33#include "safepoint-table.h"
34
35namespace v8 {
36namespace internal {
37
38int Deoptimizer::table_entry_size_ = 16;
39
Steve Block1e0659c2011-05-24 12:43:12 +010040
41int Deoptimizer::patch_size() {
42 const int kCallInstructionSizeInWords = 3;
43 return kCallInstructionSizeInWords * Assembler::kInstrSize;
44}
45
46
47
Ben Murdochb0fe1622011-05-05 13:52:32 +010048void Deoptimizer::DeoptimizeFunction(JSFunction* function) {
49 AssertNoAllocation no_allocation;
50
51 if (!function->IsOptimized()) return;
52
53 // Get the optimized code.
54 Code* code = function->code();
55
56 // Invalidate the relocation information, as it will become invalid by the
57 // code patching below, and is not needed any more.
58 code->InvalidateRelocation();
59
60 // For each return after a safepoint insert an absolute call to the
61 // corresponding deoptimization entry.
Steve Block1e0659c2011-05-24 12:43:12 +010062 ASSERT(patch_size() % Assembler::kInstrSize == 0);
63 int call_size_in_words = patch_size() / Assembler::kInstrSize;
Ben Murdochb0fe1622011-05-05 13:52:32 +010064 unsigned last_pc_offset = 0;
65 SafepointTable table(function->code());
66 for (unsigned i = 0; i < table.length(); i++) {
67 unsigned pc_offset = table.GetPcOffset(i);
Ben Murdochb8e0da22011-05-16 14:20:40 +010068 SafepointEntry safepoint_entry = table.GetEntry(i);
69 int deoptimization_index = safepoint_entry.deoptimization_index();
70 int gap_code_size = safepoint_entry.gap_code_size();
Ben Murdochb0fe1622011-05-05 13:52:32 +010071 // Check that we did not shoot past next safepoint.
72 // TODO(srdjan): How do we guarantee that safepoint code does not
73 // overlap other safepoint patching code?
74 CHECK(pc_offset >= last_pc_offset);
75#ifdef DEBUG
76 // Destroy the code which is not supposed to be run again.
77 int instructions = (pc_offset - last_pc_offset) / Assembler::kInstrSize;
78 CodePatcher destroyer(code->instruction_start() + last_pc_offset,
79 instructions);
80 for (int x = 0; x < instructions; x++) {
81 destroyer.masm()->bkpt(0);
82 }
83#endif
84 last_pc_offset = pc_offset;
85 if (deoptimization_index != Safepoint::kNoDeoptimizationIndex) {
Steve Block1e0659c2011-05-24 12:43:12 +010086 last_pc_offset += gap_code_size;
87 CodePatcher patcher(code->instruction_start() + last_pc_offset,
88 call_size_in_words);
Ben Murdochb0fe1622011-05-05 13:52:32 +010089 Address deoptimization_entry = Deoptimizer::GetDeoptimizationEntry(
90 deoptimization_index, Deoptimizer::LAZY);
91 patcher.masm()->Call(deoptimization_entry, RelocInfo::NONE);
Steve Block1e0659c2011-05-24 12:43:12 +010092 last_pc_offset += patch_size();
Ben Murdochb0fe1622011-05-05 13:52:32 +010093 }
94 }
95
96
97#ifdef DEBUG
98 // Destroy the code which is not supposed to be run again.
99 int instructions =
Steve Block1e0659c2011-05-24 12:43:12 +0100100 (code->safepoint_table_offset() - last_pc_offset) / Assembler::kInstrSize;
Ben Murdochb0fe1622011-05-05 13:52:32 +0100101 CodePatcher destroyer(code->instruction_start() + last_pc_offset,
102 instructions);
103 for (int x = 0; x < instructions; x++) {
104 destroyer.masm()->bkpt(0);
105 }
106#endif
107
108 // Add the deoptimizing code to the list.
109 DeoptimizingCodeListNode* node = new DeoptimizingCodeListNode(code);
110 node->set_next(deoptimizing_code_list_);
111 deoptimizing_code_list_ = node;
112
113 // Set the code for the function to non-optimized version.
114 function->ReplaceCode(function->shared()->code());
115
116 if (FLAG_trace_deopt) {
117 PrintF("[forced deoptimization: ");
118 function->PrintName();
119 PrintF(" / %x]\n", reinterpret_cast<uint32_t>(function));
120 }
121}
122
123
Steve Block1e0659c2011-05-24 12:43:12 +0100124void Deoptimizer::PatchStackCheckCodeAt(Address pc_after,
125 Code* check_code,
126 Code* replacement_code) {
Ben Murdoche0cee9b2011-05-25 10:26:03 +0100127 const int kInstrSize = Assembler::kInstrSize;
128 // The call of the stack guard check has the following form:
129 // e1 5d 00 0c cmp sp, <limit>
130 // 2a 00 00 01 bcs ok
131 // e5 9f c? ?? ldr ip, [pc, <stack guard address>]
132 // e1 2f ff 3c blx ip
133 ASSERT(Memory::int32_at(pc_after - kInstrSize) ==
134 (al | B24 | B21 | 15*B16 | 15*B12 | 15*B8 | BLX | ip.code()));
135 ASSERT(Assembler::IsLdrPcImmediateOffset(
136 Assembler::instr_at(pc_after - 2 * kInstrSize)));
137
138 // We patch the code to the following form:
139 // e1 5d 00 0c cmp sp, <limit>
140 // e1 a0 00 00 mov r0, r0 (NOP)
141 // e5 9f c? ?? ldr ip, [pc, <on-stack replacement address>]
142 // e1 2f ff 3c blx ip
143 // and overwrite the constant containing the
144 // address of the stack check stub.
145
146 // Replace conditional jump with NOP.
147 CodePatcher patcher(pc_after - 3 * kInstrSize, 1);
148 patcher.masm()->nop();
149
150 // Replace the stack check address in the constant pool
151 // with the entry address of the replacement code.
152 uint32_t stack_check_address_offset = Memory::uint16_at(pc_after -
153 2 * kInstrSize) & 0xfff;
154 Address stack_check_address_pointer = pc_after + stack_check_address_offset;
155 ASSERT(Memory::uint32_at(stack_check_address_pointer) ==
156 reinterpret_cast<uint32_t>(check_code->entry()));
157 Memory::uint32_at(stack_check_address_pointer) =
158 reinterpret_cast<uint32_t>(replacement_code->entry());
Ben Murdochb0fe1622011-05-05 13:52:32 +0100159}
160
161
Steve Block1e0659c2011-05-24 12:43:12 +0100162void Deoptimizer::RevertStackCheckCodeAt(Address pc_after,
163 Code* check_code,
164 Code* replacement_code) {
Ben Murdoche0cee9b2011-05-25 10:26:03 +0100165 const int kInstrSize = Assembler::kInstrSize;
166 ASSERT(Memory::uint32_at(pc_after - kInstrSize) == 0xe12fff3c);
167 ASSERT(Memory::uint8_at(pc_after - kInstrSize - 1) == 0xe5);
168 ASSERT(Memory::uint8_at(pc_after - kInstrSize - 2) == 0x9f);
169
170 // Replace NOP with conditional jump.
171 CodePatcher patcher(pc_after - 3 * kInstrSize, 1);
172 patcher.masm()->b(+4, cs);
173
174 // Replace the stack check address in the constant pool
175 // with the entry address of the replacement code.
176 uint32_t stack_check_address_offset = Memory::uint16_at(pc_after -
177 2 * kInstrSize) & 0xfff;
178 Address stack_check_address_pointer = pc_after + stack_check_address_offset;
179 ASSERT(Memory::uint32_at(stack_check_address_pointer) ==
180 reinterpret_cast<uint32_t>(replacement_code->entry()));
181 Memory::uint32_at(stack_check_address_pointer) =
182 reinterpret_cast<uint32_t>(check_code->entry());
Ben Murdochb0fe1622011-05-05 13:52:32 +0100183}
184
185
Steve Block1e0659c2011-05-24 12:43:12 +0100186static int LookupBailoutId(DeoptimizationInputData* data, unsigned ast_id) {
187 ByteArray* translations = data->TranslationByteArray();
188 int length = data->DeoptCount();
189 for (int i = 0; i < length; i++) {
190 if (static_cast<unsigned>(data->AstId(i)->value()) == ast_id) {
191 TranslationIterator it(translations, data->TranslationIndex(i)->value());
192 int value = it.Next();
193 ASSERT(Translation::BEGIN == static_cast<Translation::Opcode>(value));
194 // Read the number of frames.
195 value = it.Next();
196 if (value == 1) return i;
197 }
198 }
199 UNREACHABLE();
200 return -1;
201}
202
203
Ben Murdochb0fe1622011-05-05 13:52:32 +0100204void Deoptimizer::DoComputeOsrOutputFrame() {
Steve Block1e0659c2011-05-24 12:43:12 +0100205 DeoptimizationInputData* data = DeoptimizationInputData::cast(
206 optimized_code_->deoptimization_data());
207 unsigned ast_id = data->OsrAstId()->value();
208
209 int bailout_id = LookupBailoutId(data, ast_id);
210 unsigned translation_index = data->TranslationIndex(bailout_id)->value();
211 ByteArray* translations = data->TranslationByteArray();
212
213 TranslationIterator iterator(translations, translation_index);
214 Translation::Opcode opcode =
215 static_cast<Translation::Opcode>(iterator.Next());
216 ASSERT(Translation::BEGIN == opcode);
217 USE(opcode);
218 int count = iterator.Next();
219 ASSERT(count == 1);
220 USE(count);
221
222 opcode = static_cast<Translation::Opcode>(iterator.Next());
223 USE(opcode);
224 ASSERT(Translation::FRAME == opcode);
225 unsigned node_id = iterator.Next();
226 USE(node_id);
227 ASSERT(node_id == ast_id);
228 JSFunction* function = JSFunction::cast(ComputeLiteral(iterator.Next()));
229 USE(function);
230 ASSERT(function == function_);
231 unsigned height = iterator.Next();
232 unsigned height_in_bytes = height * kPointerSize;
233 USE(height_in_bytes);
234
235 unsigned fixed_size = ComputeFixedSize(function_);
236 unsigned input_frame_size = input_->GetFrameSize();
237 ASSERT(fixed_size + height_in_bytes == input_frame_size);
238
239 unsigned stack_slot_size = optimized_code_->stack_slots() * kPointerSize;
240 unsigned outgoing_height = data->ArgumentsStackHeight(bailout_id)->value();
241 unsigned outgoing_size = outgoing_height * kPointerSize;
242 unsigned output_frame_size = fixed_size + stack_slot_size + outgoing_size;
243 ASSERT(outgoing_size == 0); // OSR does not happen in the middle of a call.
244
245 if (FLAG_trace_osr) {
246 PrintF("[on-stack replacement: begin 0x%08" V8PRIxPTR " ",
247 reinterpret_cast<intptr_t>(function_));
248 function_->PrintName();
249 PrintF(" => node=%u, frame=%d->%d]\n",
250 ast_id,
251 input_frame_size,
252 output_frame_size);
253 }
254
255 // There's only one output frame in the OSR case.
256 output_count_ = 1;
257 output_ = new FrameDescription*[1];
258 output_[0] = new(output_frame_size) FrameDescription(
259 output_frame_size, function_);
260
261 // Clear the incoming parameters in the optimized frame to avoid
262 // confusing the garbage collector.
263 unsigned output_offset = output_frame_size - kPointerSize;
264 int parameter_count = function_->shared()->formal_parameter_count() + 1;
265 for (int i = 0; i < parameter_count; ++i) {
266 output_[0]->SetFrameSlot(output_offset, 0);
267 output_offset -= kPointerSize;
268 }
269
270 // Translate the incoming parameters. This may overwrite some of the
271 // incoming argument slots we've just cleared.
272 int input_offset = input_frame_size - kPointerSize;
273 bool ok = true;
274 int limit = input_offset - (parameter_count * kPointerSize);
275 while (ok && input_offset > limit) {
276 ok = DoOsrTranslateCommand(&iterator, &input_offset);
277 }
278
279 // There are no translation commands for the caller's pc and fp, the
280 // context, and the function. Set them up explicitly.
281 for (int i = 0; ok && i < 4; i++) {
282 uint32_t input_value = input_->GetFrameSlot(input_offset);
283 if (FLAG_trace_osr) {
284 PrintF(" [sp + %d] <- 0x%08x ; [sp + %d] (fixed part)\n",
285 output_offset,
286 input_value,
287 input_offset);
288 }
289 output_[0]->SetFrameSlot(output_offset, input_->GetFrameSlot(input_offset));
290 input_offset -= kPointerSize;
291 output_offset -= kPointerSize;
292 }
293
294 // Translate the rest of the frame.
295 while (ok && input_offset >= 0) {
296 ok = DoOsrTranslateCommand(&iterator, &input_offset);
297 }
298
299 // If translation of any command failed, continue using the input frame.
300 if (!ok) {
301 delete output_[0];
302 output_[0] = input_;
303 output_[0]->SetPc(reinterpret_cast<uint32_t>(from_));
304 } else {
305 // Setup the frame pointer and the context pointer.
306 output_[0]->SetRegister(fp.code(), input_->GetRegister(fp.code()));
307 output_[0]->SetRegister(cp.code(), input_->GetRegister(cp.code()));
308
309 unsigned pc_offset = data->OsrPcOffset()->value();
310 uint32_t pc = reinterpret_cast<uint32_t>(
311 optimized_code_->entry() + pc_offset);
312 output_[0]->SetPc(pc);
313 }
314 Code* continuation = Builtins::builtin(Builtins::NotifyOSR);
315 output_[0]->SetContinuation(
316 reinterpret_cast<uint32_t>(continuation->entry()));
317
318 if (FLAG_trace_osr) {
319 PrintF("[on-stack replacement translation %s: 0x%08" V8PRIxPTR " ",
320 ok ? "finished" : "aborted",
321 reinterpret_cast<intptr_t>(function));
322 function->PrintName();
323 PrintF(" => pc=0x%0x]\n", output_[0]->GetPc());
324 }
Ben Murdochb0fe1622011-05-05 13:52:32 +0100325}
326
327
328// This code is very similar to ia32 code, but relies on register names (fp, sp)
329// and how the frame is laid out.
330void Deoptimizer::DoComputeFrame(TranslationIterator* iterator,
331 int frame_index) {
332 // Read the ast node id, function, and frame height for this output frame.
333 Translation::Opcode opcode =
334 static_cast<Translation::Opcode>(iterator->Next());
335 USE(opcode);
336 ASSERT(Translation::FRAME == opcode);
337 int node_id = iterator->Next();
338 JSFunction* function = JSFunction::cast(ComputeLiteral(iterator->Next()));
339 unsigned height = iterator->Next();
340 unsigned height_in_bytes = height * kPointerSize;
341 if (FLAG_trace_deopt) {
342 PrintF(" translating ");
343 function->PrintName();
344 PrintF(" => node=%d, height=%d\n", node_id, height_in_bytes);
345 }
346
347 // The 'fixed' part of the frame consists of the incoming parameters and
348 // the part described by JavaScriptFrameConstants.
349 unsigned fixed_frame_size = ComputeFixedSize(function);
350 unsigned input_frame_size = input_->GetFrameSize();
351 unsigned output_frame_size = height_in_bytes + fixed_frame_size;
352
353 // Allocate and store the output frame description.
354 FrameDescription* output_frame =
355 new(output_frame_size) FrameDescription(output_frame_size, function);
356
357 bool is_bottommost = (0 == frame_index);
358 bool is_topmost = (output_count_ - 1 == frame_index);
359 ASSERT(frame_index >= 0 && frame_index < output_count_);
360 ASSERT(output_[frame_index] == NULL);
361 output_[frame_index] = output_frame;
362
363 // The top address for the bottommost output frame can be computed from
364 // the input frame pointer and the output frame's height. For all
365 // subsequent output frames, it can be computed from the previous one's
366 // top address and the current frame's size.
367 uint32_t top_address;
368 if (is_bottommost) {
369 // 2 = context and function in the frame.
370 top_address =
371 input_->GetRegister(fp.code()) - (2 * kPointerSize) - height_in_bytes;
372 } else {
373 top_address = output_[frame_index - 1]->GetTop() - output_frame_size;
374 }
375 output_frame->SetTop(top_address);
376
377 // Compute the incoming parameter translation.
378 int parameter_count = function->shared()->formal_parameter_count() + 1;
379 unsigned output_offset = output_frame_size;
380 unsigned input_offset = input_frame_size;
381 for (int i = 0; i < parameter_count; ++i) {
382 output_offset -= kPointerSize;
383 DoTranslateCommand(iterator, frame_index, output_offset);
384 }
385 input_offset -= (parameter_count * kPointerSize);
386
387 // There are no translation commands for the caller's pc and fp, the
388 // context, and the function. Synthesize their values and set them up
389 // explicitly.
390 //
391 // The caller's pc for the bottommost output frame is the same as in the
392 // input frame. For all subsequent output frames, it can be read from the
393 // previous one. This frame's pc can be computed from the non-optimized
394 // function code and AST id of the bailout.
395 output_offset -= kPointerSize;
396 input_offset -= kPointerSize;
397 intptr_t value;
398 if (is_bottommost) {
399 value = input_->GetFrameSlot(input_offset);
400 } else {
401 value = output_[frame_index - 1]->GetPc();
402 }
403 output_frame->SetFrameSlot(output_offset, value);
404 if (FLAG_trace_deopt) {
405 PrintF(" 0x%08x: [top + %d] <- 0x%08x ; caller's pc\n",
406 top_address + output_offset, output_offset, value);
407 }
408
409 // The caller's frame pointer for the bottommost output frame is the same
410 // as in the input frame. For all subsequent output frames, it can be
411 // read from the previous one. Also compute and set this frame's frame
412 // pointer.
413 output_offset -= kPointerSize;
414 input_offset -= kPointerSize;
415 if (is_bottommost) {
416 value = input_->GetFrameSlot(input_offset);
417 } else {
418 value = output_[frame_index - 1]->GetFp();
419 }
420 output_frame->SetFrameSlot(output_offset, value);
421 intptr_t fp_value = top_address + output_offset;
422 ASSERT(!is_bottommost || input_->GetRegister(fp.code()) == fp_value);
423 output_frame->SetFp(fp_value);
424 if (is_topmost) {
425 output_frame->SetRegister(fp.code(), fp_value);
426 }
427 if (FLAG_trace_deopt) {
428 PrintF(" 0x%08x: [top + %d] <- 0x%08x ; caller's fp\n",
429 fp_value, output_offset, value);
430 }
431
Ben Murdoche0cee9b2011-05-25 10:26:03 +0100432 // For the bottommost output frame the context can be gotten from the input
433 // frame. For all subsequent output frames it can be gotten from the function
434 // so long as we don't inline functions that need local contexts.
Ben Murdochb0fe1622011-05-05 13:52:32 +0100435 output_offset -= kPointerSize;
436 input_offset -= kPointerSize;
Ben Murdoche0cee9b2011-05-25 10:26:03 +0100437 if (is_bottommost) {
438 value = input_->GetFrameSlot(input_offset);
439 } else {
440 value = reinterpret_cast<intptr_t>(function->context());
441 }
Ben Murdochb0fe1622011-05-05 13:52:32 +0100442 output_frame->SetFrameSlot(output_offset, value);
443 if (is_topmost) {
444 output_frame->SetRegister(cp.code(), value);
445 }
446 if (FLAG_trace_deopt) {
447 PrintF(" 0x%08x: [top + %d] <- 0x%08x ; context\n",
448 top_address + output_offset, output_offset, value);
449 }
450
451 // The function was mentioned explicitly in the BEGIN_FRAME.
452 output_offset -= kPointerSize;
453 input_offset -= kPointerSize;
454 value = reinterpret_cast<uint32_t>(function);
455 // The function for the bottommost output frame should also agree with the
456 // input frame.
457 ASSERT(!is_bottommost || input_->GetFrameSlot(input_offset) == value);
458 output_frame->SetFrameSlot(output_offset, value);
459 if (FLAG_trace_deopt) {
460 PrintF(" 0x%08x: [top + %d] <- 0x%08x ; function\n",
461 top_address + output_offset, output_offset, value);
462 }
463
464 // Translate the rest of the frame.
465 for (unsigned i = 0; i < height; ++i) {
466 output_offset -= kPointerSize;
467 DoTranslateCommand(iterator, frame_index, output_offset);
468 }
469 ASSERT(0 == output_offset);
470
471 // Compute this frame's PC, state, and continuation.
472 Code* non_optimized_code = function->shared()->code();
473 FixedArray* raw_data = non_optimized_code->deoptimization_data();
474 DeoptimizationOutputData* data = DeoptimizationOutputData::cast(raw_data);
475 Address start = non_optimized_code->instruction_start();
476 unsigned pc_and_state = GetOutputInfo(data, node_id, function->shared());
477 unsigned pc_offset = FullCodeGenerator::PcField::decode(pc_and_state);
478 uint32_t pc_value = reinterpret_cast<uint32_t>(start + pc_offset);
479 output_frame->SetPc(pc_value);
480 if (is_topmost) {
481 output_frame->SetRegister(pc.code(), pc_value);
482 }
483
484 FullCodeGenerator::State state =
485 FullCodeGenerator::StateField::decode(pc_and_state);
486 output_frame->SetState(Smi::FromInt(state));
487
488 // Set the continuation for the topmost frame.
489 if (is_topmost) {
490 Code* continuation = (bailout_type_ == EAGER)
491 ? Builtins::builtin(Builtins::NotifyDeoptimized)
492 : Builtins::builtin(Builtins::NotifyLazyDeoptimized);
493 output_frame->SetContinuation(
494 reinterpret_cast<uint32_t>(continuation->entry()));
495 }
496
497 if (output_count_ - 1 == frame_index) iterator->Done();
498}
499
500
501#define __ masm()->
502
503
504// This code tries to be close to ia32 code so that any changes can be
505// easily ported.
506void Deoptimizer::EntryGenerator::Generate() {
507 GeneratePrologue();
Ben Murdochb0fe1622011-05-05 13:52:32 +0100508 CpuFeatures::Scope scope(VFP3);
509 // Save all general purpose registers before messing with them.
510 const int kNumberOfRegisters = Register::kNumRegisters;
511
512 // Everything but pc, lr and ip which will be saved but not restored.
513 RegList restored_regs = kJSCallerSaved | kCalleeSaved | ip.bit();
514
515 const int kDoubleRegsSize =
516 kDoubleSize * DwVfpRegister::kNumAllocatableRegisters;
517
518 // Save all general purpose registers before messing with them.
519 __ sub(sp, sp, Operand(kDoubleRegsSize));
520 for (int i = 0; i < DwVfpRegister::kNumAllocatableRegisters; ++i) {
521 DwVfpRegister vfp_reg = DwVfpRegister::FromAllocationIndex(i);
522 int offset = i * kDoubleSize;
523 __ vstr(vfp_reg, sp, offset);
524 }
525
526 // Push all 16 registers (needed to populate FrameDescription::registers_).
527 __ stm(db_w, sp, restored_regs | sp.bit() | lr.bit() | pc.bit());
528
529 const int kSavedRegistersAreaSize =
530 (kNumberOfRegisters * kPointerSize) + kDoubleRegsSize;
531
532 // Get the bailout id from the stack.
533 __ ldr(r2, MemOperand(sp, kSavedRegistersAreaSize));
534
535 // Get the address of the location in the code object if possible (r3) (return
536 // address for lazy deoptimization) and compute the fp-to-sp delta in
537 // register r4.
538 if (type() == EAGER) {
539 __ mov(r3, Operand(0));
540 // Correct one word for bailout id.
541 __ add(r4, sp, Operand(kSavedRegistersAreaSize + (1 * kPointerSize)));
Steve Block1e0659c2011-05-24 12:43:12 +0100542 } else if (type() == OSR) {
543 __ mov(r3, lr);
544 // Correct one word for bailout id.
545 __ add(r4, sp, Operand(kSavedRegistersAreaSize + (1 * kPointerSize)));
Ben Murdochb0fe1622011-05-05 13:52:32 +0100546 } else {
547 __ mov(r3, lr);
548 // Correct two words for bailout id and return address.
549 __ add(r4, sp, Operand(kSavedRegistersAreaSize + (2 * kPointerSize)));
550 }
551 __ sub(r4, fp, r4);
552
553 // Allocate a new deoptimizer object.
554 // Pass four arguments in r0 to r3 and fifth argument on stack.
555 __ PrepareCallCFunction(5, r5);
556 __ ldr(r0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
557 __ mov(r1, Operand(type())); // bailout type,
558 // r2: bailout id already loaded.
559 // r3: code address or 0 already loaded.
560 __ str(r4, MemOperand(sp, 0 * kPointerSize)); // Fp-to-sp delta.
561 // Call Deoptimizer::New().
562 __ CallCFunction(ExternalReference::new_deoptimizer_function(), 5);
563
564 // Preserve "deoptimizer" object in register r0 and get the input
565 // frame descriptor pointer to r1 (deoptimizer->input_);
566 __ ldr(r1, MemOperand(r0, Deoptimizer::input_offset()));
567
Ben Murdochb0fe1622011-05-05 13:52:32 +0100568 // Copy core registers into FrameDescription::registers_[kNumRegisters].
569 ASSERT(Register::kNumRegisters == kNumberOfRegisters);
570 for (int i = 0; i < kNumberOfRegisters; i++) {
Steve Block1e0659c2011-05-24 12:43:12 +0100571 int offset = (i * kPointerSize) + FrameDescription::registers_offset();
Ben Murdochb0fe1622011-05-05 13:52:32 +0100572 __ ldr(r2, MemOperand(sp, i * kPointerSize));
573 __ str(r2, MemOperand(r1, offset));
574 }
575
576 // Copy VFP registers to
577 // double_registers_[DoubleRegister::kNumAllocatableRegisters]
578 int double_regs_offset = FrameDescription::double_registers_offset();
579 for (int i = 0; i < DwVfpRegister::kNumAllocatableRegisters; ++i) {
580 int dst_offset = i * kDoubleSize + double_regs_offset;
581 int src_offset = i * kDoubleSize + kNumberOfRegisters * kPointerSize;
582 __ vldr(d0, sp, src_offset);
583 __ vstr(d0, r1, dst_offset);
584 }
585
586 // Remove the bailout id, eventually return address, and the saved registers
587 // from the stack.
Steve Block1e0659c2011-05-24 12:43:12 +0100588 if (type() == EAGER || type() == OSR) {
Ben Murdochb0fe1622011-05-05 13:52:32 +0100589 __ add(sp, sp, Operand(kSavedRegistersAreaSize + (1 * kPointerSize)));
590 } else {
591 __ add(sp, sp, Operand(kSavedRegistersAreaSize + (2 * kPointerSize)));
592 }
593
594 // Compute a pointer to the unwinding limit in register r2; that is
595 // the first stack slot not part of the input frame.
596 __ ldr(r2, MemOperand(r1, FrameDescription::frame_size_offset()));
597 __ add(r2, r2, sp);
598
599 // Unwind the stack down to - but not including - the unwinding
600 // limit and copy the contents of the activation frame to the input
601 // frame description.
602 __ add(r3, r1, Operand(FrameDescription::frame_content_offset()));
603 Label pop_loop;
604 __ bind(&pop_loop);
605 __ pop(r4);
606 __ str(r4, MemOperand(r3, 0));
607 __ add(r3, r3, Operand(sizeof(uint32_t)));
608 __ cmp(r2, sp);
609 __ b(ne, &pop_loop);
610
611 // Compute the output frame in the deoptimizer.
612 __ push(r0); // Preserve deoptimizer object across call.
613 // r0: deoptimizer object; r1: scratch.
614 __ PrepareCallCFunction(1, r1);
615 // Call Deoptimizer::ComputeOutputFrames().
616 __ CallCFunction(ExternalReference::compute_output_frames_function(), 1);
617 __ pop(r0); // Restore deoptimizer object (class Deoptimizer).
618
619 // Replace the current (input) frame with the output frames.
620 Label outer_push_loop, inner_push_loop;
621 // Outer loop state: r0 = current "FrameDescription** output_",
622 // r1 = one past the last FrameDescription**.
623 __ ldr(r1, MemOperand(r0, Deoptimizer::output_count_offset()));
624 __ ldr(r0, MemOperand(r0, Deoptimizer::output_offset())); // r0 is output_.
625 __ add(r1, r0, Operand(r1, LSL, 2));
626 __ bind(&outer_push_loop);
627 // Inner loop state: r2 = current FrameDescription*, r3 = loop index.
628 __ ldr(r2, MemOperand(r0, 0)); // output_[ix]
629 __ ldr(r3, MemOperand(r2, FrameDescription::frame_size_offset()));
630 __ bind(&inner_push_loop);
631 __ sub(r3, r3, Operand(sizeof(uint32_t)));
632 // __ add(r6, r2, Operand(r3, LSL, 1));
633 __ add(r6, r2, Operand(r3));
634 __ ldr(r7, MemOperand(r6, FrameDescription::frame_content_offset()));
635 __ push(r7);
636 __ cmp(r3, Operand(0));
637 __ b(ne, &inner_push_loop); // test for gt?
638 __ add(r0, r0, Operand(kPointerSize));
639 __ cmp(r0, r1);
640 __ b(lt, &outer_push_loop);
641
Ben Murdochb0fe1622011-05-05 13:52:32 +0100642 // Push state, pc, and continuation from the last output frame.
643 if (type() != OSR) {
644 __ ldr(r6, MemOperand(r2, FrameDescription::state_offset()));
645 __ push(r6);
646 }
647
648 __ ldr(r6, MemOperand(r2, FrameDescription::pc_offset()));
649 __ push(r6);
650 __ ldr(r6, MemOperand(r2, FrameDescription::continuation_offset()));
651 __ push(r6);
652
653 // Push the registers from the last output frame.
654 for (int i = kNumberOfRegisters - 1; i >= 0; i--) {
Steve Block1e0659c2011-05-24 12:43:12 +0100655 int offset = (i * kPointerSize) + FrameDescription::registers_offset();
Ben Murdochb0fe1622011-05-05 13:52:32 +0100656 __ ldr(r6, MemOperand(r2, offset));
657 __ push(r6);
658 }
659
660 // Restore the registers from the stack.
661 __ ldm(ia_w, sp, restored_regs); // all but pc registers.
662 __ pop(ip); // remove sp
663 __ pop(ip); // remove lr
664
665 // Set up the roots register.
666 ExternalReference roots_address = ExternalReference::roots_address();
667 __ mov(r10, Operand(roots_address));
668
669 __ pop(ip); // remove pc
670 __ pop(r7); // get continuation, leave pc on stack
671 __ pop(lr);
672 __ Jump(r7);
673 __ stop("Unreachable.");
674}
675
676
677void Deoptimizer::TableEntryGenerator::GeneratePrologue() {
678 // Create a sequence of deoptimization entries. Note that any
679 // registers may be still live.
680 Label done;
681 for (int i = 0; i < count(); i++) {
682 int start = masm()->pc_offset();
683 USE(start);
684 if (type() == EAGER) {
685 __ nop();
686 } else {
687 // Emulate ia32 like call by pushing return address to stack.
688 __ push(lr);
689 }
690 __ mov(ip, Operand(i));
691 __ push(ip);
692 __ b(&done);
693 ASSERT(masm()->pc_offset() - start == table_entry_size_);
694 }
695 __ bind(&done);
696}
697
698#undef __
699
700} } // namespace v8::internal