SafepointEntry safepoint = code->GetSafepointEntry(it.frame()->pc());
int deopt_index = safepoint.deoptimization_index();
// Turbofan deopt is checked when we are patching addresses on stack.
- bool turbofanned = code->is_turbofanned();
+ bool turbofanned = code->is_turbofanned() && !FLAG_turbo_deoptimization;
bool safe_to_deopt =
deopt_index != Safepoint::kNoDeoptimizationIndex || turbofanned;
CHECK(topmost_optimized_code == NULL || safe_to_deopt || turbofanned);
CHECK_EQ(code->kind(), Code::OPTIMIZED_FUNCTION);
Object* next = code->next_code_link();
- if (code->marked_for_deoptimization()) {
+ if (code->marked_for_deoptimization() &&
+ (!code->is_turbofanned() || FLAG_turbo_deoptimization)) {
// Put the code into the list for later patching.
codes.Add(code, &zone);
element = next;
}
- if (FLAG_turbo_deoptimization) {
- PatchStackForMarkedCode(isolate);
- }
-
// TODO(titzer): we need a handle scope only because of the macro assembler,
// which is only used in EnsureCodeForDeoptimizationEntry.
HandleScope scope(isolate);
shared->EvictFromOptimizedCodeMap(codes[i], "deoptimized code");
// Do platform-specific patching to force any activations to lazy deopt.
- //
- // We skip patching Turbofan code - we patch return addresses on stack.
- // TODO(jarin) We should still zap the code object (but we have to
- // be careful not to zap the deoptimization block).
- if (!codes[i]->is_turbofanned()) {
+ if (!codes[i]->is_turbofanned() || FLAG_turbo_deoptimization) {
PatchCodeForDeoptimization(isolate, codes[i]);
// We might be in the middle of incremental marking with compaction.
}
-static int FindPatchAddressForReturnAddress(Code* code, int pc) {
- DeoptimizationInputData* input_data =
- DeoptimizationInputData::cast(code->deoptimization_data());
- int patch_count = input_data->ReturnAddressPatchCount();
- for (int i = 0; i < patch_count; i++) {
- int return_pc = input_data->ReturnAddressPc(i)->value();
- int patch_pc = input_data->PatchedAddressPc(i)->value();
- // If the supplied pc matches the return pc or if the address
- // has been already patched, return the patch pc.
- if (pc == return_pc || pc == patch_pc) {
- return patch_pc;
- }
- }
- return -1;
-}
-
-
-// For all marked Turbofanned code on stack, change the return address to go
-// to the deoptimization block.
-void Deoptimizer::PatchStackForMarkedCode(Isolate* isolate) {
- // TODO(jarin) We should tolerate missing patch entry for the topmost frame.
- for (StackFrameIterator it(isolate, isolate->thread_local_top()); !it.done();
- it.Advance()) {
- StackFrame::Type type = it.frame()->type();
- if (type == StackFrame::OPTIMIZED) {
- Code* code = it.frame()->LookupCode();
- if (code->is_turbofanned() && code->marked_for_deoptimization()) {
- JSFunction* function =
- static_cast<OptimizedFrame*>(it.frame())->function();
- Address* pc_address = it.frame()->pc_address();
- int pc_offset =
- static_cast<int>(*pc_address - code->instruction_start());
- int new_pc_offset = FindPatchAddressForReturnAddress(code, pc_offset);
-
- if (FLAG_trace_deopt) {
- CodeTracer::Scope scope(isolate->GetCodeTracer());
- PrintF(scope.file(), "[patching stack address for function: ");
- function->PrintName(scope.file());
- PrintF(scope.file(), " (Pc offset %i -> %i)]\n", pc_offset,
- new_pc_offset);
- }
-
- CHECK_LE(0, new_pc_offset);
- *pc_address += new_pc_offset - pc_offset;
- }
- }
- }
-}
-
-
void Deoptimizer::DeoptimizeAll(Isolate* isolate) {
if (FLAG_trace_deopt) {
CodeTracer::Scope scope(isolate->GetCodeTracer());
CHECK_EQ(Translation::kSelfLiteralId, closure_id);
function = function_;
}
- unsigned height = iterator->Next();
+ unsigned height = iterator->Next() - 1; // Do not count the context.
unsigned height_in_bytes = height * kPointerSize;
if (trace_scope_ != NULL) {
PrintF(trace_scope_->file(), " translating ");
Register context_reg = JavaScriptFrame::context_register();
output_offset -= kPointerSize;
input_offset -= kPointerSize;
- if (is_bottommost) {
- value = input_->GetFrameSlot(input_offset);
- } else {
- value = reinterpret_cast<intptr_t>(function->context());
+ // Read the context from the translations.
+ DoTranslateCommand(iterator, frame_index, output_offset);
+ value = output_frame->GetFrameSlot(output_offset);
+ // The context should not be a placeholder for a materialized object.
+ CHECK(value !=
+ reinterpret_cast<intptr_t>(isolate_->heap()->arguments_marker()));
+ if (value ==
+ reinterpret_cast<intptr_t>(isolate_->heap()->undefined_value())) {
+ // If the context was optimized away, just use the context from
+ // the activation. This should only apply to Crankshaft code.
+ CHECK(!compiled_code_->is_turbofanned());
+ if (is_bottommost) {
+ value = input_->GetFrameSlot(input_offset);
+ } else {
+ value = reinterpret_cast<intptr_t>(function->context());
+ }
+ output_frame->SetFrameSlot(output_offset, value);
}
- output_frame->SetFrameSlot(output_offset, value);
output_frame->SetContext(value);
if (is_topmost) output_frame->SetRegister(context_reg.code(), value);
if (trace_scope_ != NULL) {
CHECK(compiled_code_->is_hydrogen_stub());
int major_key = CodeStub::GetMajorKey(compiled_code_);
- CodeStubInterfaceDescriptor* descriptor =
- isolate_->code_stub_interface_descriptor(major_key);
- // Check that there is a matching descriptor to the major key.
- // This will fail if there has not been one installed to the isolate.
- DCHECK_EQ(descriptor->MajorKey(), major_key);
+ CodeStubDescriptor descriptor(isolate_, compiled_code_->stub_key());
// The output frame must have room for all pushed register parameters
// and the standard stack frame slots. Include space for an argument
// object to the callee and optionally the space to pass the argument
// object to the stub failure handler.
- int param_count = descriptor->GetEnvironmentParameterCount();
+ int param_count = descriptor.GetEnvironmentParameterCount();
CHECK_GE(param_count, 0);
int height_in_bytes = kPointerSize * param_count + sizeof(Arguments) +
}
intptr_t caller_arg_count = 0;
- bool arg_count_known = !descriptor->stack_parameter_count().is_valid();
+ bool arg_count_known = !descriptor.stack_parameter_count().is_valid();
// Build the Arguments object for the caller's parameters and a pointer to it.
output_frame_offset -= kPointerSize;
output_frame_offset -= kPointerSize;
DoTranslateCommand(iterator, 0, output_frame_offset);
- if (!arg_count_known &&
- descriptor->IsEnvironmentParameterCountRegister(i)) {
+ if (!arg_count_known && descriptor.IsEnvironmentParameterCountRegister(i)) {
arguments_length_offset = output_frame_offset;
}
}
}
// Copy the double registers from the input into the output frame.
- CopySIMD128Registers(output_frame);
+ CopyDoubleRegisters(output_frame);
// Fill registers containing handler and number of parameters.
- SetPlatformCompiledStubRegisters(output_frame, descriptor);
+ SetPlatformCompiledStubRegisters(output_frame, &descriptor);
// Compute this frame's PC, state, and continuation.
Code* trampoline = NULL;
- StubFunctionMode function_mode = descriptor->function_mode();
+ StubFunctionMode function_mode = descriptor.function_mode();
StubFailureTrampolineStub(isolate_,
function_mode).FindCodeInCache(&trampoline);
DCHECK(trampoline != NULL);
Memory::Object_at(d.destination()) = *num;
}
- // Materialize all float32x4 before looking at arguments because when the
- // output frames are used to materialize arguments objects later on they need
- // to already contain valid float32x4 values.
- for (int i = 0; i < deferred_float32x4s_.length(); i++) {
- SIMD128MaterializationDescriptor<Address> d = deferred_float32x4s_[i];
- float32x4_value_t x4 = d.value().f4;
- Handle<Object> float32x4 = isolate_->factory()->NewFloat32x4(x4);
- if (trace_scope_ != NULL) {
- PrintF(trace_scope_->file(),
- "Materialized a new float32x4 %p "
- "[float32x4(%e, %e, %e, %e)] in slot %p\n",
- reinterpret_cast<void*>(*float32x4),
- x4.storage[0], x4.storage[1], x4.storage[2], x4.storage[3],
- d.destination());
- }
- Memory::Object_at(d.destination()) = *float32x4;
- }
-
- // Materialize all float64x2 before looking at arguments because when the
- // output frames are used to materialize arguments objects later on they need
- // to already contain valid float64x2 values.
- for (int i = 0; i < deferred_float64x2s_.length(); i++) {
- SIMD128MaterializationDescriptor<Address> d = deferred_float64x2s_[i];
- float64x2_value_t x2 = d.value().d2;
- Handle<Object> float64x2 = isolate_->factory()->NewFloat64x2(x2);
- if (trace_scope_ != NULL) {
- PrintF(trace_scope_->file(),
- "Materialized a new float64x2 %p "
- "[float64x2(%e, %e)] in slot %p\n",
- reinterpret_cast<void*>(*float64x2),
- x2.storage[0], x2.storage[1],
- d.destination());
- }
- Memory::Object_at(d.destination()) = *float64x2;
- }
-
- // Materialize all int32x4 before looking at arguments because when the
- // output frames are used to materialize arguments objects later on they need
- // to already contain valid int32x4 values.
- for (int i = 0; i < deferred_int32x4s_.length(); i++) {
- SIMD128MaterializationDescriptor<Address> d = deferred_int32x4s_[i];
- int32x4_value_t x4 = d.value().i4;
- Handle<Object> int32x4 = isolate_->factory()->NewInt32x4(x4);
- if (trace_scope_ != NULL) {
- PrintF(trace_scope_->file(),
- "Materialized a new int32x4 %p "
- "[int32x4(%u, %u, %u, %u)] in slot %p\n",
- reinterpret_cast<void*>(*int32x4),
- x4.storage[0], x4.storage[1], x4.storage[2], x4.storage[3],
- d.destination());
- }
- Memory::Object_at(d.destination()) = *int32x4;
- }
-
-
// Materialize all heap numbers required for arguments/captured objects.
for (int i = 0; i < deferred_objects_double_values_.length(); i++) {
HeapNumberMaterializationDescriptor<int> d =
// Play it safe and clear all object double values before we continue.
deferred_objects_double_values_.Clear();
- // Materialize all float32x4 values required for arguments/captured objects.
- for (int i = 0; i < deferred_objects_float32x4_values_.length(); i++) {
- SIMD128MaterializationDescriptor<int> d =
- deferred_objects_float32x4_values_[i];
- float32x4_value_t x4 = d.value().f4;
- Handle<Object> float32x4 = isolate_->factory()->NewFloat32x4(x4);
- if (trace_scope_ != NULL) {
- PrintF(trace_scope_->file(),
- "Materialized a new float32x4 %p "
- "[float32x4(%e, %e, %e, %e)] for object at %d\n",
- reinterpret_cast<void*>(*float32x4),
- x4.storage[0], x4.storage[1], x4.storage[2], x4.storage[3],
- d.destination());
- }
- DCHECK(values.at(d.destination())->IsTheHole());
- values.Set(d.destination(), float32x4);
- }
-
- // Play it safe and clear all object float32x4 values before we continue.
- deferred_objects_float32x4_values_.Clear();
-
- // Materialize all float64x2 values required for arguments/captured objects.
- for (int i = 0; i < deferred_objects_float64x2_values_.length(); i++) {
- SIMD128MaterializationDescriptor<int> d =
- deferred_objects_float64x2_values_[i];
- float64x2_value_t x2 = d.value().d2;
- Handle<Object> float64x2 = isolate_->factory()->NewFloat64x2(x2);
- if (trace_scope_ != NULL) {
- PrintF(trace_scope_->file(),
- "Materialized a new float64x2 %p "
- "[float64x2(%e, %e)] for object at %d\n",
- reinterpret_cast<void*>(*float64x2),
- x2.storage[0], x2.storage[1],
- d.destination());
- }
- DCHECK(values.at(d.destination())->IsTheHole());
- values.Set(d.destination(), float64x2);
- }
-
- // Play it safe and clear all object float64x2 values before we continue.
- deferred_objects_float64x2_values_.Clear();
-
- // Materialize all int32x4 values required for arguments/captured objects.
- for (int i = 0; i < deferred_objects_int32x4_values_.length(); i++) {
- SIMD128MaterializationDescriptor<int> d =
- deferred_objects_int32x4_values_[i];
- int32x4_value_t x4 = d.value().i4;
- Handle<Object> int32x4 = isolate_->factory()->NewInt32x4(x4);
- if (trace_scope_ != NULL) {
- PrintF(trace_scope_->file(),
- "Materialized a new int32x4 %p "
- "[int32x4(%u, %u, %u, %u)] for object at %d\n",
- reinterpret_cast<void*>(*int32x4),
- x4.storage[0], x4.storage[1], x4.storage[2], x4.storage[3],
- d.destination());
- }
- DCHECK(values.at(d.destination())->IsTheHole());
- values.Set(d.destination(), int32x4);
- }
-
- // Play it safe and clear all object int32x4 values before we continue.
- deferred_objects_int32x4_values_.Clear();
-
// Materialize arguments/captured objects.
if (!deferred_objects_.is_empty()) {
List<Handle<Object> > materialized_objects(deferred_objects_.length());
case Translation::INT32_REGISTER:
case Translation::UINT32_REGISTER:
case Translation::DOUBLE_REGISTER:
- case Translation::FLOAT32x4_REGISTER:
- case Translation::FLOAT64x2_REGISTER:
- case Translation::INT32x4_REGISTER:
case Translation::STACK_SLOT:
case Translation::INT32_STACK_SLOT:
case Translation::UINT32_STACK_SLOT:
case Translation::DOUBLE_STACK_SLOT:
- case Translation::FLOAT32x4_STACK_SLOT:
- case Translation::FLOAT64x2_STACK_SLOT:
- case Translation::INT32x4_STACK_SLOT:
case Translation::LITERAL: {
// The value is not part of any materialized object, so we can ignore it.
iterator->Skip(Translation::NumberOfOperandsFor(opcode));
return;
}
- case Translation::FLOAT32x4_REGISTER:
- case Translation::FLOAT64x2_REGISTER:
- case Translation::INT32x4_REGISTER: {
- int input_reg = iterator->Next();
- simd128_value_t value = input_->GetSIMD128Register(input_reg);
- if (trace_scope_ != NULL) {
- if (opcode == Translation::FLOAT32x4_REGISTER) {
- float32x4_value_t x4 = value.f4;
- PrintF(trace_scope_->file(),
- " object @0x%08" V8PRIxPTR ": [field #%d] <- ",
- reinterpret_cast<intptr_t>(object_slot),
- field_index);
- PrintF(trace_scope_->file(),
- "float32x4(%e, %e, %e, %e) ; %s\n",
- x4.storage[0], x4.storage[1], x4.storage[2], x4.storage[3],
- SIMD128Register::AllocationIndexToString(input_reg));
- } else if (opcode == Translation::FLOAT64x2_REGISTER) {
- float64x2_value_t x2 = value.d2;
- PrintF(trace_scope_->file(),
- " object @0x%08" V8PRIxPTR ": [field #%d] <- ",
- reinterpret_cast<intptr_t>(object_slot),
- field_index);
- PrintF(trace_scope_->file(),
- "float64x2(%e, %e) ; %s\n",
- x2.storage[0], x2.storage[1],
- SIMD128Register::AllocationIndexToString(input_reg));
- } else {
- DCHECK(opcode == Translation::INT32x4_REGISTER);
- int32x4_value_t x4 = value.i4;
- PrintF(trace_scope_->file(),
- " object @0x%08" V8PRIxPTR ": [field #%d] <- ",
- reinterpret_cast<intptr_t>(object_slot),
- field_index);
- PrintF(trace_scope_->file(),
- "int32x4(%u, %u, %u, %u) ; %s\n",
- x4.storage[0], x4.storage[1], x4.storage[2], x4.storage[3],
- SIMD128Register::AllocationIndexToString(input_reg));
- }
- }
- AddObjectSIMD128Value(value, opcode);
- return;
- }
-
case Translation::STACK_SLOT: {
int input_slot_index = iterator->Next();
unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
return;
}
- case Translation::FLOAT32x4_STACK_SLOT:
- case Translation::FLOAT64x2_STACK_SLOT:
- case Translation::INT32x4_STACK_SLOT: {
- int input_slot_index = iterator->Next();
- unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
- simd128_value_t value = input_->GetSIMD128FrameSlot(input_offset);
- if (trace_scope_ != NULL) {
- if (opcode == Translation::FLOAT32x4_STACK_SLOT) {
- float32x4_value_t x4 = value.f4;
- PrintF(trace_scope_->file(),
- " object @0x%08" V8PRIxPTR ": [field #%d] <- ",
- reinterpret_cast<intptr_t>(object_slot),
- field_index);
- PrintF(trace_scope_->file(),
- "float32x4(%e, %e, %e, %e) ; [sp + %d]\n",
- x4.storage[0], x4.storage[1], x4.storage[2], x4.storage[3],
- input_offset);
- } else if (opcode == Translation::FLOAT64x2_STACK_SLOT) {
- float64x2_value_t x2 = value.d2;
- PrintF(trace_scope_->file(),
- " object @0x%08" V8PRIxPTR ": [field #%d] <- ",
- reinterpret_cast<intptr_t>(object_slot),
- field_index);
- PrintF(trace_scope_->file(),
- "float64x2(%e, %e) ; [sp + %d]\n",
- x2.storage[0], x2.storage[1],
- input_offset);
- } else {
- DCHECK(opcode == Translation::INT32x4_STACK_SLOT);
- int32x4_value_t x4 = value.i4;
- PrintF(trace_scope_->file(),
- " object @0x%08" V8PRIxPTR ": [field #%d] <- ",
- reinterpret_cast<intptr_t>(object_slot),
- field_index);
- PrintF(trace_scope_->file(),
- "int32x4(%u, %u, %u, %u) ; [sp + %d]\n",
- x4.storage[0], x4.storage[1], x4.storage[2], x4.storage[3],
- input_offset);
- }
- }
- AddObjectSIMD128Value(value, opcode);
- return;
- }
-
case Translation::LITERAL: {
Object* literal = ComputeLiteral(iterator->Next());
if (trace_scope_ != NULL) {
return;
}
- case Translation::FLOAT32x4_REGISTER:
- case Translation::FLOAT64x2_REGISTER:
- case Translation::INT32x4_REGISTER: {
- int input_reg = iterator->Next();
- simd128_value_t value = input_->GetSIMD128Register(input_reg);
- if (trace_scope_ != NULL) {
- if (opcode == Translation::FLOAT32x4_REGISTER) {
- float32x4_value_t x4 = value.f4;
- PrintF(trace_scope_->file(),
- " 0x%08" V8PRIxPTR ":"
- " [top + %d] <- float32x4(%e, %e, %e, %e) ; %s\n",
- output_[frame_index]->GetTop() + output_offset,
- output_offset,
- x4.storage[0], x4.storage[1], x4.storage[2], x4.storage[3],
- SIMD128Register::AllocationIndexToString(input_reg));
- } else if (opcode == Translation::FLOAT64x2_REGISTER) {
- float64x2_value_t x2 = value.d2;
- PrintF(trace_scope_->file(),
- " 0x%08" V8PRIxPTR ":"
- " [top + %d] <- float64x2(%e, %e) ; %s\n",
- output_[frame_index]->GetTop() + output_offset,
- output_offset,
- x2.storage[0], x2.storage[1],
- SIMD128Register::AllocationIndexToString(input_reg));
- } else {
- DCHECK(opcode == Translation::INT32x4_REGISTER);
- int32x4_value_t x4 = value.i4;
- PrintF(trace_scope_->file(),
- " 0x%08" V8PRIxPTR ":"
- " [top + %d] <- int32x4(%u, %u, %u, %u) ; %s\n",
- output_[frame_index]->GetTop() + output_offset,
- output_offset,
- x4.storage[0], x4.storage[1], x4.storage[2], x4.storage[3],
- SIMD128Register::AllocationIndexToString(input_reg));
- }
- }
- // We save the untagged value on the side and store a GC-safe
- // temporary placeholder in the frame.
- AddSIMD128Value(output_[frame_index]->GetTop() + output_offset, value,
- opcode);
- output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
- return;
- }
-
case Translation::STACK_SLOT: {
int input_slot_index = iterator->Next();
unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
return;
}
- case Translation::FLOAT32x4_STACK_SLOT:
- case Translation::FLOAT64x2_STACK_SLOT:
- case Translation::INT32x4_STACK_SLOT: {
- int input_slot_index = iterator->Next();
- unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
- simd128_value_t value = input_->GetSIMD128FrameSlot(input_offset);
- if (trace_scope_ != NULL) {
- if (opcode == Translation::FLOAT32x4_STACK_SLOT) {
- float32x4_value_t x4 = value.f4;
- PrintF(trace_scope_->file(),
- " 0x%08" V8PRIxPTR ": "
- "[top + %d] <- float32x4(%e, %e, %e, %e) ; [sp + %d]\n",
- output_[frame_index]->GetTop() + output_offset,
- output_offset,
- x4.storage[0], x4.storage[1], x4.storage[2], x4.storage[3],
- input_offset);
- } else if (opcode == Translation::FLOAT64x2_STACK_SLOT) {
- float64x2_value_t x2 = value.d2;
- PrintF(trace_scope_->file(),
- " 0x%08" V8PRIxPTR ": "
- "[top + %d] <- float64x2(%e, %e) ; [sp + %d]\n",
- output_[frame_index]->GetTop() + output_offset,
- output_offset,
- x2.storage[0], x2.storage[1],
- input_offset);
- } else {
- DCHECK(opcode == Translation::INT32x4_STACK_SLOT);
- int32x4_value_t x4 = value.i4;
- PrintF(trace_scope_->file(),
- " 0x%08" V8PRIxPTR ": "
- "[top + %d] <- int32x4(%u, %u, %u, %u) ; [sp + %d]\n",
- output_[frame_index]->GetTop() + output_offset,
- output_offset,
- x4.storage[0], x4.storage[1], x4.storage[2], x4.storage[3],
- input_offset);
- }
- }
- // We save the untagged value on the side and store a GC-safe
- // temporary placeholder in the frame.
- AddSIMD128Value(output_[frame_index]->GetTop() + output_offset, value,
- opcode);
- output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
- return;
- }
-
case Translation::LITERAL: {
Object* literal = ComputeLiteral(iterator->Next());
if (trace_scope_ != NULL) {
}
-void Deoptimizer::AddObjectSIMD128Value(simd128_value_t value,
- int translation_opcode) {
- deferred_objects_tagged_values_.Add(isolate()->heap()->the_hole_value());
- SIMD128MaterializationDescriptor<int> value_desc(
- deferred_objects_tagged_values_.length() - 1, value);
- Translation::Opcode opcode =
- static_cast<Translation::Opcode>(translation_opcode);
- if (opcode == Translation::FLOAT32x4_REGISTER ||
- opcode == Translation::FLOAT32x4_STACK_SLOT) {
- deferred_objects_float32x4_values_.Add(value_desc);
- } else if (opcode == Translation::FLOAT64x2_REGISTER ||
- opcode == Translation::FLOAT64x2_STACK_SLOT) {
- deferred_objects_float64x2_values_.Add(value_desc);
- } else {
- DCHECK(opcode == Translation::INT32x4_REGISTER ||
- opcode == Translation::INT32x4_STACK_SLOT);
- deferred_objects_int32x4_values_.Add(value_desc);
- }
-}
-
-
void Deoptimizer::AddDoubleValue(intptr_t slot_address, double value) {
HeapNumberMaterializationDescriptor<Address> value_desc(
reinterpret_cast<Address>(slot_address), value);
}
-void Deoptimizer::AddSIMD128Value(intptr_t slot_address,
- simd128_value_t value,
- int translation_opcode) {
- SIMD128MaterializationDescriptor<Address> value_desc(
- reinterpret_cast<Address>(slot_address), value);
- Translation::Opcode opcode =
- static_cast<Translation::Opcode>(translation_opcode);
- if (opcode == Translation::FLOAT32x4_REGISTER ||
- opcode == Translation::FLOAT32x4_STACK_SLOT) {
- deferred_float32x4s_.Add(value_desc);
- } else if (opcode == Translation::FLOAT64x2_REGISTER ||
- opcode == Translation::FLOAT64x2_STACK_SLOT) {
- deferred_float64x2s_.Add(value_desc);
- } else {
- DCHECK(opcode == Translation::INT32x4_REGISTER ||
- opcode == Translation::INT32x4_STACK_SLOT);
- deferred_int32x4s_.Add(value_desc);
- }
-}
-
-
void Deoptimizer::EnsureCodeForDeoptimizationEntry(Isolate* isolate,
BailoutType type,
int max_entry_id) {
}
-void Translation::StoreSIMD128Register(SIMD128Register reg, Opcode opcode) {
- buffer_->Add(opcode, zone());
- buffer_->Add(SIMD128Register::ToAllocationIndex(reg), zone());
-}
-
-
void Translation::StoreStackSlot(int index) {
buffer_->Add(STACK_SLOT, zone());
buffer_->Add(index, zone());
}
-void Translation::StoreSIMD128StackSlot(int index, Opcode opcode) {
- buffer_->Add(opcode, zone());
- buffer_->Add(index, zone());
-}
-
-
void Translation::StoreLiteral(int literal_id) {
buffer_->Add(LITERAL, zone());
buffer_->Add(literal_id, zone());
case INT32_REGISTER:
case UINT32_REGISTER:
case DOUBLE_REGISTER:
- case FLOAT32x4_REGISTER:
- case FLOAT64x2_REGISTER:
- case INT32x4_REGISTER:
case STACK_SLOT:
case INT32_STACK_SLOT:
case UINT32_STACK_SLOT:
case DOUBLE_STACK_SLOT:
- case FLOAT32x4_STACK_SLOT:
- case FLOAT64x2_STACK_SLOT:
- case INT32x4_STACK_SLOT:
case LITERAL:
case COMPILED_STUB_FRAME:
return 1;
case Translation::INT32_REGISTER:
case Translation::UINT32_REGISTER:
case Translation::DOUBLE_REGISTER:
- case Translation::FLOAT32x4_REGISTER:
- case Translation::FLOAT64x2_REGISTER:
- case Translation::INT32x4_REGISTER:
// We are at safepoint which corresponds to call. All registers are
// saved by caller so there would be no live registers at this
// point. Thus these translation commands should not be used.
return SlotRef(slot_addr, SlotRef::DOUBLE);
}
- case Translation::FLOAT32x4_STACK_SLOT: {
- int slot_index = iterator->Next();
- Address slot_addr = SlotAddress(frame, slot_index);
- return SlotRef(slot_addr, SlotRef::FLOAT32x4);
- }
-
- case Translation::FLOAT64x2_STACK_SLOT: {
- int slot_index = iterator->Next();
- Address slot_addr = SlotAddress(frame, slot_index);
- return SlotRef(slot_addr, SlotRef::FLOAT64x2);
- }
-
- case Translation::INT32x4_STACK_SLOT: {
- int slot_index = iterator->Next();
- Address slot_addr = SlotAddress(frame, slot_index);
- return SlotRef(slot_addr, SlotRef::INT32x4);
- }
-
case Translation::LITERAL: {
int literal_index = iterator->Next();
return SlotRef(data->GetIsolate(),
return isolate->factory()->NewNumber(value);
}
- case FLOAT32x4:
- return isolate->factory()->NewFloat32x4(read_simd128_value(addr_).f4);
-
- case FLOAT64x2:
- return isolate->factory()->NewFloat64x2(read_simd128_value(addr_).d2);
-
- case INT32x4:
- return isolate->factory()->NewInt32x4(read_simd128_value(addr_).i4);
-
case LITERAL:
return literal_;
bool has_construct_stub) {
FrameDescription* output_frame = deoptimizer->output_[frame_index];
function_ = output_frame->GetFunction();
+ context_ = reinterpret_cast<Object*>(output_frame->GetContext());
has_construct_stub_ = has_construct_stub;
expression_count_ = output_frame->GetExpressionCount();
expression_stack_ = new Object*[expression_count_];
void DeoptimizedFrameInfo::Iterate(ObjectVisitor* v) {
- v->VisitPointer(BitCast<Object**>(&function_));
+ v->VisitPointer(bit_cast<Object**>(&function_));
+ v->VisitPointer(&context_);
v->VisitPointers(parameters_, parameters_ + parameters_count_);
v->VisitPointers(expression_stack_, expression_stack_ + expression_count_);
}
projects / platform / framework / web / crosswalk.git / blobdiff