#include <deoptimizer.h>

Inheritance diagram for v8::internal::Deoptimizer:

Collaboration diagram for v8::internal::Deoptimizer:

Classes
class	BASE_EMBEDDED

struct	JumpTableEntry

struct	Reason

class	TableEntryGenerator

Public Types
enum	BailoutType { EAGER , LAZY , SOFT , DEBUGGER }

enum	GetEntryMode { CALCULATE_ENTRY_ADDRESS , ENSURE_ENTRY_CODE }

Public Member Functions
int	output_count () const

Handle< JSFunction >	function () const

Handle< Code >	compiled_code () const

BailoutType	bailout_type () const

int	jsframe_count () const

	~Deoptimizer ()

void	MaterializeHeapObjects (JavaScriptFrameIterator *it)

void	MaterializeHeapNumbersForDebuggerInspectableFrame (Address parameters_top, uint32_t parameters_size, Address expressions_top, uint32_t expressions_size, DeoptimizedFrameInfo *info)

int	ConvertJSFrameIndexToFrameIndex (int jsframe_index)

Isolate *	isolate () const

Public Member Functions inherited from v8::internal::Malloced
void *	operator new (size_t size)

void	operator delete (void *p)

Static Public Member Functions
static bool	TraceEnabledFor (BailoutType deopt_type, StackFrame::Type frame_type)

static const char *	MessageFor (BailoutType type)

static Deoptimizer *	New (JSFunction function, BailoutType type, unsigned bailout_id, Address from, int fp_to_sp_delta, Isolate isolate)

static Deoptimizer *	Grab (Isolate *isolate)

static DeoptimizedFrameInfo *	DebuggerInspectableFrame (JavaScriptFrame frame, int jsframe_index, Isolate isolate)

static void	DeleteDebuggerInspectableFrame (DeoptimizedFrameInfo info, Isolate isolate)

static void	EnsureRelocSpaceForLazyDeoptimization (Handle< Code > code)

static void	DeoptimizeFunction (JSFunction *function)

static void	DeoptimizeAll (Isolate *isolate)

static void	DeoptimizeGlobalObject (JSObject *object)

static void	DeoptimizeMarkedCode (Isolate *isolate)

static void	VisitAllOptimizedFunctions (Isolate isolate, OptimizedFunctionVisitor visitor)

static int	patch_size ()

static void	ComputeOutputFrames (Deoptimizer *deoptimizer)

static Address	GetDeoptimizationEntry (Isolate *isolate, int id, BailoutType type, GetEntryMode mode=ENSURE_ENTRY_CODE)

static int	GetDeoptimizationId (Isolate *isolate, Address addr, BailoutType type)

static int	GetOutputInfo (DeoptimizationOutputData data, BailoutId node_id, SharedFunctionInfo shared)

static int	input_offset ()

static int	output_count_offset ()

static int	output_offset ()

static int	has_alignment_padding_offset ()

static int	GetDeoptimizedCodeCount (Isolate *isolate)

static size_t	GetMaxDeoptTableSize ()

static void	EnsureCodeForDeoptimizationEntry (Isolate *isolate, BailoutType type, int max_entry_id)

Static Public Member Functions inherited from v8::internal::Malloced
static void	FatalProcessOutOfMemory ()

static void *	New (size_t size)

static void	Delete (void *p)

Static Public Attributes
static const int	kBailoutTypesWithCodeEntry = SOFT + 1

static const int	kNotDeoptimizationEntry = -1

Private Member Functions
	Deoptimizer (Isolate isolate, JSFunction function, BailoutType type, unsigned bailout_id, Address from, int fp_to_sp_delta, Code *optimized_code)

Code *	FindOptimizedCode (JSFunction function, Code optimized_code)

void	PrintFunctionName ()

void	DeleteFrameDescriptions ()

void	DoComputeOutputFrames ()

void	DoComputeJSFrame (TranslationIterator *iterator, int frame_index)

void	DoComputeArgumentsAdaptorFrame (TranslationIterator *iterator, int frame_index)

void	DoComputeConstructStubFrame (TranslationIterator *iterator, int frame_index)

void	DoComputeAccessorStubFrame (TranslationIterator *iterator, int frame_index, bool is_setter_stub_frame)

void	DoComputeCompiledStubFrame (TranslationIterator *iterator, int frame_index)

void	DoTranslateObject (TranslationIterator *iterator, int object_index, int field_index)

void	DoTranslateCommand (TranslationIterator *iterator, int frame_index, unsigned output_offset)

void	DoTranslateObjectAndSkip (TranslationIterator *iterator)

unsigned	ComputeInputFrameSize () const

unsigned	ComputeFixedSize (JSFunction *function) const

unsigned	ComputeIncomingArgumentSize (JSFunction *function) const

unsigned	ComputeOutgoingArgumentSize () const

Object *	ComputeLiteral (int index) const

void	AddObjectStart (intptr_t slot_address, int argc, bool is_arguments)

void	AddObjectDuplication (intptr_t slot, int object_index)

void	AddObjectTaggedValue (intptr_t value)

void	AddObjectDoubleValue (double value)

void	AddDoubleValue (intptr_t slot_address, double value)

bool	ArgumentsObjectIsAdapted (int object_index)

Handle< JSFunction >	ArgumentsObjectFunction (int object_index)

Handle< Object >	MaterializeNextHeapObject ()

Handle< Object >	MaterializeNextValue ()

Code *	FindDeoptimizingCode (Address addr)

void	FillInputFrame (Address tos, JavaScriptFrame *frame)

void	SetPlatformCompiledStubRegisters (FrameDescription output_frame, CodeStubDescriptor desc)

void	CopyDoubleRegisters (FrameDescription *output_frame)

bool	HasAlignmentPadding (JSFunction *function)

Static Private Member Functions
static void	GenerateDeoptimizationEntries (MacroAssembler *masm, int count, BailoutType type)

static void	MarkAllCodeForContext (Context *native_context)

static void	VisitAllOptimizedFunctionsForContext (Context context, OptimizedFunctionVisitor visitor)

static void	DeoptimizeMarkedCodeForContext (Context *native_context)

static void	PatchCodeForDeoptimization (Isolate isolate, Code code)

Private Attributes
Isolate *	isolate_

JSFunction *	function_

Code *	compiled_code_

unsigned	bailout_id_

BailoutType	bailout_type_

Address	from_

int	fp_to_sp_delta_

int	has_alignment_padding_

FrameDescription *	input_

int	output_count_

int	jsframe_count_

FrameDescription **	output_

List< Object * >	deferred_objects_tagged_values_

List< HeapNumberMaterializationDescriptor< int > >	deferred_objects_double_values_

List< ObjectMaterializationDescriptor >	deferred_objects_

List< HeapNumberMaterializationDescriptor< Address > >	deferred_heap_numbers_

Address	stack_fp_

Handle< FixedArray >	previously_materialized_objects_

int	prev_materialized_count_

List< Handle< JSFunction > >	jsframe_functions_

List< bool >	jsframe_has_adapted_arguments_

List< Handle< Object > > *	materialized_values_

List< Handle< Object > > *	materialized_objects_

int	materialization_value_index_

int	materialization_object_index_

CodeTracer::Scope *	trace_scope_

Static Private Attributes
static const int	kMinNumberOfEntries = 64

static const int	kMaxNumberOfEntries = 16384

static const int	table_entry_size_ = 8

Friends
class	FrameDescription

class	DeoptimizedFrameInfo

Detailed Description

Definition at line 91 of file deoptimizer.h.

Member Enumeration Documentation

◆ BailoutType

enum v8::internal::Deoptimizer::BailoutType

Enumerator
EAGER
LAZY
SOFT
DEBUGGER

Definition at line 93 of file deoptimizer.h.

                    {
     EAGER,
     LAZY,
     SOFT,
     // This last bailout type is not really a bailout, but used by the
     // debugger to deoptimize stack frames to allow inspection.
     DEBUGGER
   };

◆ GetEntryMode

enum v8::internal::Deoptimizer::GetEntryMode

Enumerator
CALCULATE_ENTRY_ADDRESS
ENSURE_ENTRY_CODE

Definition at line 216 of file deoptimizer.h.

                     {
     CALCULATE_ENTRY_ADDRESS,
     ENSURE_ENTRY_CODE
   };

Constructor & Destructor Documentation

◆ ~Deoptimizer()

v8::internal::Deoptimizer::~Deoptimizer ( )

Definition at line 648 of file deoptimizer.cc.

                           {
   DCHECK(input_ == NULL && output_ == NULL);
   DCHECK(disallow_heap_allocation_ == NULL);
   delete trace_scope_;
 }

References DCHECK, input_, NULL, output_, and trace_scope_.

◆ Deoptimizer()

v8::internal::Deoptimizer::Deoptimizer	(	Isolate *	isolate,
		JSFunction *	function,
		BailoutType	type,
		unsigned	bailout_id,
		Address	from,
		int	fp_to_sp_delta,
		Code *	optimized_code
	)

private

Definition at line 548 of file deoptimizer.cc.

     : isolate_(isolate),
       function_(function),
       bailout_id_(bailout_id),
       bailout_type_(type),
       from_(from),
       fp_to_sp_delta_(fp_to_sp_delta),
       has_alignment_padding_(0),
       input_(NULL),
       output_count_(0),
       jsframe_count_(0),
       output_(NULL),
       deferred_objects_tagged_values_(0),
       deferred_objects_double_values_(0),
       deferred_objects_(0),
       deferred_heap_numbers_(0),
       jsframe_functions_(0),
       jsframe_has_adapted_arguments_(0),
       materialized_values_(NULL),
       materialized_objects_(NULL),
       materialization_value_index_(0),
       materialization_object_index_(0),
       trace_scope_(NULL) {
   // For COMPILED_STUBs called from builtins, the function pointer is a SMI
   // indicating an internal frame.
   if (function->IsSmi()) {
     function = NULL;
   }
   DCHECK(from != NULL);
   if (function != NULL && function->IsOptimized()) {
     function->shared()->increment_deopt_count();
     if (bailout_type_ == Deoptimizer::SOFT) {
       isolate->counters()->soft_deopts_executed()->Increment();
       // Soft deopts shouldn't count against the overall re-optimization count
       // that can eventually lead to disabling optimization for a function.
       int opt_count = function->shared()->opt_count();
       if (opt_count > 0) opt_count--;
       function->shared()->set_opt_count(opt_count);
     }
   }
   compiled_code_ = FindOptimizedCode(function, optimized_code);
  
 #if DEBUG
   DCHECK(compiled_code_ != NULL);
   if (type == EAGER || type == SOFT || type == LAZY) {
     DCHECK(compiled_code_->kind() != Code::FUNCTION);
   }
 #endif
  
   StackFrame::Type frame_type = function == NULL
       ? StackFrame::STUB
       : StackFrame::JAVA_SCRIPT;
   trace_scope_ = TraceEnabledFor(type, frame_type) ?
       new CodeTracer::Scope(isolate->GetCodeTracer()) : NULL;
 #ifdef DEBUG
   CHECK(AllowHeapAllocation::IsAllowed());
   disallow_heap_allocation_ = new DisallowHeapAllocation();
 #endif  // DEBUG
   unsigned size = ComputeInputFrameSize();
   input_ = new(size) FrameDescription(size, function);
   input_->SetFrameType(frame_type);
 }

References bailout_type_, CHECK, compiled_code_, ComputeInputFrameSize(), v8::internal::Isolate::counters(), DCHECK, EAGER, FindOptimizedCode(), FrameDescription, function(), v8::internal::Isolate::GetCodeTracer(), input_, isolate(), v8::internal::Code::kind(), LAZY, NULL, v8::internal::FrameDescription::SetFrameType(), size, SOFT, v8::internal::STUB, trace_scope_, and TraceEnabledFor().

Referenced by DebuggerInspectableFrame(), and New().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

◆ AddDoubleValue()

void v8::internal::Deoptimizer::AddDoubleValue	(	intptr_t	slot_address,
		double	value
	)

private

Definition at line 2783 of file deoptimizer.cc.

                                                                     {
   HeapNumberMaterializationDescriptor<Address> value_desc(
       reinterpret_cast<Address>(slot_address), value);
   deferred_heap_numbers_.Add(value_desc);
 }

References v8::internal::List< T, AllocationPolicy >::Add(), and deferred_heap_numbers_.

Referenced by DoTranslateCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddObjectDoubleValue()

void v8::internal::Deoptimizer::AddObjectDoubleValue ( double value )

private

Definition at line 2775 of file deoptimizer.cc.

                                                    {
   deferred_objects_tagged_values_.Add(isolate()->heap()->the_hole_value());
   HeapNumberMaterializationDescriptor<int> value_desc(
       deferred_objects_tagged_values_.length() - 1, value);
   deferred_objects_double_values_.Add(value_desc);
 }

References v8::internal::List< T, AllocationPolicy >::Add(), deferred_objects_double_values_, deferred_objects_tagged_values_, and isolate().

Referenced by DoTranslateObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddObjectDuplication()

void v8::internal::Deoptimizer::AddObjectDuplication	(	intptr_t	slot,
		int	object_index
	)

private

Definition at line 2763 of file deoptimizer.cc.

                                                                       {
   ObjectMaterializationDescriptor object_desc(
       reinterpret_cast<Address>(slot), jsframe_count_, -1, object_index, false);
   deferred_objects_.Add(object_desc);
 }

References v8::internal::List< T, AllocationPolicy >::Add(), deferred_objects_, and jsframe_count_.

Referenced by DoTranslateCommand(), DoTranslateObject(), and DoTranslateObjectAndSkip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddObjectStart()

void v8::internal::Deoptimizer::AddObjectStart	(	intptr_t	slot_address,
		int	argc,
		bool	is_arguments
	)

private

Definition at line 2756 of file deoptimizer.cc.

                                                                         {
   ObjectMaterializationDescriptor object_desc(
       reinterpret_cast<Address>(slot), jsframe_count_, length, -1, is_args);
   deferred_objects_.Add(object_desc);
 }

References v8::internal::List< T, AllocationPolicy >::Add(), deferred_objects_, and jsframe_count_.

Referenced by DoTranslateCommand(), DoTranslateObject(), and DoTranslateObjectAndSkip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddObjectTaggedValue()

void v8::internal::Deoptimizer::AddObjectTaggedValue ( intptr_t value )

private

Definition at line 2770 of file deoptimizer.cc.

                                                      {
   deferred_objects_tagged_values_.Add(reinterpret_cast<Object*>(value));
 }

References deferred_objects_tagged_values_.

Referenced by DoTranslateObject().

Here is the caller graph for this function:

◆ ArgumentsObjectFunction()

Handle<JSFunction> v8::internal::Deoptimizer::ArgumentsObjectFunction ( int object_index )

inlineprivate

Definition at line 356 of file deoptimizer.h.

                                                                {
     ObjectMaterializationDescriptor desc = deferred_objects_.at(object_index);
     int reverse_jsframe_index = jsframe_count_ - desc.jsframe_index() - 1;
     return jsframe_functions_[reverse_jsframe_index];
   }

References v8::internal::List< T, AllocationPolicy >::at(), deferred_objects_, jsframe_count_, and jsframe_functions_.

Referenced by MaterializeNextHeapObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ArgumentsObjectIsAdapted()

bool v8::internal::Deoptimizer::ArgumentsObjectIsAdapted ( int object_index )

inlineprivate

Definition at line 350 of file deoptimizer.h.

                                                   {
     ObjectMaterializationDescriptor desc = deferred_objects_.at(object_index);
     int reverse_jsframe_index = jsframe_count_ - desc.jsframe_index() - 1;
     return jsframe_has_adapted_arguments_[reverse_jsframe_index];
   }

References v8::internal::List< T, AllocationPolicy >::at(), deferred_objects_, jsframe_count_, and jsframe_has_adapted_arguments_.

Referenced by MaterializeHeapObjects(), and MaterializeNextHeapObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bailout_type()

BailoutType v8::internal::Deoptimizer::bailout_type ( ) const

inline

Definition at line 151 of file deoptimizer.h.

151 { return bailout_type_; }

References bailout_type_.

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the caller graph for this function:

◆ compiled_code()

Handle<Code> v8::internal::Deoptimizer::compiled_code ( ) const

inline

Definition at line 150 of file deoptimizer.h.

150 { return Handle<Code>(compiled_code_); }

References compiled_code_.

Referenced by FindOptimizedCode(), and v8::internal::RUNTIME_FUNCTION().

Here is the caller graph for this function:

◆ ComputeFixedSize()

unsigned v8::internal::Deoptimizer::ComputeFixedSize ( JSFunction * function ) const

private

Definition at line 2720 of file deoptimizer.cc.

                                                                  {
   // The fixed part of the frame consists of the return address, frame
   // pointer, function, context, and all the incoming arguments.
   return ComputeIncomingArgumentSize(function) +
       StandardFrameConstants::kFixedFrameSize;
 }

References ComputeIncomingArgumentSize(), and v8::internal::StandardFrameConstants::kFixedFrameSize.

Referenced by ComputeInputFrameSize(), and DoComputeJSFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeIncomingArgumentSize()

unsigned v8::internal::Deoptimizer::ComputeIncomingArgumentSize ( JSFunction * function ) const

private

Definition at line 2728 of file deoptimizer.cc.

                                                                             {
   // The incoming arguments is the values for formal parameters and
   // the receiver. Every slot contains a pointer.
   if (function->IsSmi()) {
     CHECK_EQ(Smi::cast(function), Smi::FromInt(StackFrame::STUB));
     return 0;
   }
   unsigned arguments = function->shared()->formal_parameter_count() + 1;
   return arguments * kPointerSize;
 }

References CHECK_EQ, v8::internal::Smi::FromInt(), function(), v8::internal::kPointerSize, and v8::internal::STUB.

Referenced by ComputeFixedSize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeInputFrameSize()

unsigned v8::internal::Deoptimizer::ComputeInputFrameSize ( ) const

private

Definition at line 2705 of file deoptimizer.cc.

                                                   {
   unsigned fixed_size = ComputeFixedSize(function_);
   // The fp-to-sp delta already takes the context, constant pool pointer and the
   // function into account so we have to avoid double counting them.
   unsigned result = fixed_size + fp_to_sp_delta_ -
       StandardFrameConstants::kFixedFrameSizeFromFp;
   if (compiled_code_->kind() == Code::OPTIMIZED_FUNCTION) {
     unsigned stack_slots = compiled_code_->stack_slots();
     unsigned outgoing_size = ComputeOutgoingArgumentSize();
     CHECK(result == fixed_size + (stack_slots * kPointerSize) + outgoing_size);
   }
   return result;
 }

References CHECK, compiled_code_, ComputeFixedSize(), ComputeOutgoingArgumentSize(), fp_to_sp_delta_, function_, v8::internal::StandardFrameConstants::kFixedFrameSizeFromFp, v8::internal::Code::kind(), v8::internal::kPointerSize, and v8::internal::Code::stack_slots().

Referenced by Deoptimizer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeLiteral()

Object * v8::internal::Deoptimizer::ComputeLiteral ( int index ) const

private

Definition at line 2748 of file deoptimizer.cc.

                                                    {
   DeoptimizationInputData* data = DeoptimizationInputData::cast(
       compiled_code_->deoptimization_data());
   FixedArray* literals = data->LiteralArray();
   return literals->get(index);
 }

References compiled_code_, and literals().

Referenced by DoComputeAccessorStubFrame(), DoComputeArgumentsAdaptorFrame(), DoComputeConstructStubFrame(), DoComputeJSFrame(), DoTranslateCommand(), and DoTranslateObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeOutgoingArgumentSize()

unsigned v8::internal::Deoptimizer::ComputeOutgoingArgumentSize ( ) const

private

Definition at line 2740 of file deoptimizer.cc.

                                                         {
   DeoptimizationInputData* data = DeoptimizationInputData::cast(
       compiled_code_->deoptimization_data());
   unsigned height = data->ArgumentsStackHeight(bailout_id_)->value();
   return height * kPointerSize;
 }

References bailout_id_, compiled_code_, and v8::internal::kPointerSize.

Referenced by ComputeInputFrameSize().

Here is the caller graph for this function:

◆ ComputeOutputFrames()

void v8::internal::Deoptimizer::ComputeOutputFrames ( Deoptimizer * deoptimizer )

static

Definition at line 515 of file deoptimizer.cc.

                                                               {
   deoptimizer->DoComputeOutputFrames();
 }

References DoComputeOutputFrames().

Referenced by DebuggerInspectableFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConvertJSFrameIndexToFrameIndex()

int v8::internal::Deoptimizer::ConvertJSFrameIndexToFrameIndex ( int jsframe_index )

Definition at line 120 of file deoptimizer.cc.

                                                                   {
   if (jsframe_index == 0) return 0;
  
   int frame_index = 0;
   while (jsframe_index >= 0) {
     FrameDescription* frame = output_[frame_index];
     if (frame->GetFrameType() == StackFrame::JAVA_SCRIPT) {
       jsframe_index--;
     }
     frame_index++;
   }
  
   return frame_index - 1;
 }

References v8::internal::FrameDescription::GetFrameType(), and output_.

Referenced by DebuggerInspectableFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopyDoubleRegisters()

void v8::internal::Deoptimizer::CopyDoubleRegisters ( FrameDescription * output_frame )

private

Definition at line 114 of file deoptimizer-arm.cc.

                                                                     {
   for (int i = 0; i < DwVfpRegister::kMaxNumRegisters; ++i) {
     double double_value = input_->GetDoubleRegister(i);
     output_frame->SetDoubleRegister(i, double_value);
   }
 }

References v8::internal::FrameDescription::GetDoubleRegister(), input_, v8::internal::DwVfpRegister::kMaxNumRegisters, and v8::internal::FrameDescription::SetDoubleRegister().

Referenced by DoComputeCompiledStubFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DebuggerInspectableFrame()

DeoptimizedFrameInfo * v8::internal::Deoptimizer::DebuggerInspectableFrame	(	JavaScriptFrame *	frame,
		int	jsframe_index,
		Isolate *	isolate
	)

static

Definition at line 136 of file deoptimizer.cc.

                       {
   CHECK(frame->is_optimized());
   CHECK(isolate->deoptimizer_data()->deoptimized_frame_info_ == NULL);
  
   // Get the function and code from the frame.
   JSFunction* function = frame->function();
   Code* code = frame->LookupCode();
  
   // Locate the deoptimization point in the code. As we are at a call the
   // return address must be at a place in the code with deoptimization support.
   SafepointEntry safepoint_entry = code->GetSafepointEntry(frame->pc());
   int deoptimization_index = safepoint_entry.deoptimization_index();
   CHECK_NE(deoptimization_index, Safepoint::kNoDeoptimizationIndex);
  
   // Always use the actual stack slots when calculating the fp to sp
   // delta adding two for the function and context.
   unsigned stack_slots = code->stack_slots();
   unsigned fp_to_sp_delta = (stack_slots * kPointerSize) +
       StandardFrameConstants::kFixedFrameSizeFromFp;
  
   Deoptimizer* deoptimizer = new Deoptimizer(isolate,
                                              function,
                                              Deoptimizer::DEBUGGER,
                                              deoptimization_index,
                                              frame->pc(),
                                              fp_to_sp_delta,
                                              code);
   Address tos = frame->fp() - fp_to_sp_delta;
   deoptimizer->FillInputFrame(tos, frame);
  
   // Calculate the output frames.
   Deoptimizer::ComputeOutputFrames(deoptimizer);
  
   // Create the GC safe output frame information and register it for GC
   // handling.
   CHECK_LT(jsframe_index, deoptimizer->jsframe_count());
  
   // Convert JS frame index into frame index.
   int frame_index = deoptimizer->ConvertJSFrameIndexToFrameIndex(jsframe_index);
  
   bool has_arguments_adaptor =
       frame_index > 0 &&
       deoptimizer->output_[frame_index - 1]->GetFrameType() ==
       StackFrame::ARGUMENTS_ADAPTOR;
  
   int construct_offset = has_arguments_adaptor ? 2 : 1;
   bool has_construct_stub =
       frame_index >= construct_offset &&
       deoptimizer->output_[frame_index - construct_offset]->GetFrameType() ==
       StackFrame::CONSTRUCT;
  
   DeoptimizedFrameInfo* info = new DeoptimizedFrameInfo(deoptimizer,
                                                         frame_index,
                                                         has_arguments_adaptor,
                                                         has_construct_stub);
   isolate->deoptimizer_data()->deoptimized_frame_info_ = info;
  
   // Get the "simulated" top and size for the requested frame.
   FrameDescription* parameters_frame =
       deoptimizer->output_[
           has_arguments_adaptor ? (frame_index - 1) : frame_index];
  
   uint32_t parameters_size = (info->parameters_count() + 1) * kPointerSize;
   Address parameters_top = reinterpret_cast<Address>(
       parameters_frame->GetTop() + (parameters_frame->GetFrameSize() -
                                     parameters_size));
  
   uint32_t expressions_size = info->expression_count() * kPointerSize;
   Address expressions_top = reinterpret_cast<Address>(
       deoptimizer->output_[frame_index]->GetTop());
  
   // Done with the GC-unsafe frame descriptions. This re-enables allocation.
   deoptimizer->DeleteFrameDescriptions();
  
   // Allocate a heap number for the doubles belonging to this frame.
   deoptimizer->MaterializeHeapNumbersForDebuggerInspectableFrame(
       parameters_top, parameters_size, expressions_top, expressions_size, info);
  
   // Finished using the deoptimizer instance.
   delete deoptimizer;
  
   return info;
 }

References v8::internal::compiler::ARGUMENTS_ADAPTOR, CHECK, CHECK_LT, CHECK_NE, ComputeOutputFrames(), ConvertJSFrameIndexToFrameIndex(), DEBUGGER, DeleteFrameDescriptions(), v8::internal::DeoptimizerData::deoptimized_frame_info_, DeoptimizedFrameInfo, Deoptimizer(), v8::internal::Isolate::deoptimizer_data(), v8::internal::DeoptimizedFrameInfo::expression_count(), FillInputFrame(), v8::internal::JavaScriptFrame::function(), v8::internal::FrameDescription::GetFrameSize(), v8::internal::FrameDescription::GetFrameType(), v8::internal::Code::GetSafepointEntry(), v8::internal::FrameDescription::GetTop(), isolate(), jsframe_count(), v8::internal::StandardFrameConstants::kFixedFrameSizeFromFp, v8::internal::kPointerSize, MaterializeHeapNumbersForDebuggerInspectableFrame(), NULL, output_, v8::internal::DeoptimizedFrameInfo::parameters_count(), and v8::internal::Code::stack_slots().

Referenced by v8::internal::FrameInspector::FrameInspector().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeleteDebuggerInspectableFrame()

void v8::internal::Deoptimizer::DeleteDebuggerInspectableFrame	(	DeoptimizedFrameInfo *	info,
		Isolate *	isolate
	)

static

Definition at line 224 of file deoptimizer.cc.

                                                                    {
   CHECK_EQ(isolate->deoptimizer_data()->deoptimized_frame_info_, info);
   delete info;
   isolate->deoptimizer_data()->deoptimized_frame_info_ = NULL;
 }

References CHECK_EQ, v8::internal::DeoptimizerData::deoptimized_frame_info_, v8::internal::Isolate::deoptimizer_data(), isolate(), and NULL.

Referenced by v8::internal::FrameInspector::~FrameInspector().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeleteFrameDescriptions()

void v8::internal::Deoptimizer::DeleteFrameDescriptions ( )

private

Definition at line 655 of file deoptimizer.cc.

                                           {
   delete input_;
   for (int i = 0; i < output_count_; ++i) {
     if (output_[i] != input_) delete output_[i];
   }
   delete[] output_;
   input_ = NULL;
   output_ = NULL;
 #ifdef DEBUG
   CHECK(!AllowHeapAllocation::IsAllowed());
   CHECK(disallow_heap_allocation_ != NULL);
   delete disallow_heap_allocation_;
   disallow_heap_allocation_ = NULL;
 #endif  // DEBUG
 }

References CHECK, input_, NULL, output_, and output_count_.

Referenced by DebuggerInspectableFrame(), and Grab().

Here is the caller graph for this function:

◆ DeoptimizeAll()

void v8::internal::Deoptimizer::DeoptimizeAll ( Isolate * isolate )

static

Definition at line 437 of file deoptimizer.cc.

                                                 {
   if (FLAG_trace_deopt) {
     CodeTracer::Scope scope(isolate->GetCodeTracer());
     PrintF(scope.file(), "[deoptimize all code in all contexts]\n");
   }
   DisallowHeapAllocation no_allocation;
   // For all contexts, mark all code, then deoptimize.
   Object* context = isolate->heap()->native_contexts_list();
   while (!context->IsUndefined()) {
     Context* native_context = Context::cast(context);
     MarkAllCodeForContext(native_context);
     DeoptimizeMarkedCodeForContext(native_context);
     context = native_context->get(Context::NEXT_CONTEXT_LINK);
   }
 }

References v8::internal::Context::cast(), DeoptimizeMarkedCodeForContext(), v8::internal::FixedArray::get(), v8::internal::Isolate::GetCodeTracer(), v8::internal::Isolate::heap(), isolate(), MarkAllCodeForContext(), v8::internal::Heap::native_contexts_list(), v8::internal::Context::NEXT_CONTEXT_LINK, and v8::internal::PrintF().

Referenced by v8::Testing::DeoptimizeAll(), v8::Object::ForceDelete(), v8::internal::Heap::GarbageCollectionEpilogue(), and v8::internal::Debug::PrepareForBreakPoints().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeoptimizeFunction()

void v8::internal::Deoptimizer::DeoptimizeFunction ( JSFunction * function )

static

Definition at line 503 of file deoptimizer.cc.

                                                          {
   Code* code = function->code();
   if (code->kind() == Code::OPTIMIZED_FUNCTION) {
     // Mark the code for deoptimization and unlink any functions that also
     // refer to that code. The code cannot be shared across native contexts,
     // so we only need to search one.
     code->set_marked_for_deoptimization(true);
     DeoptimizeMarkedCodeForContext(function->context()->native_context());
   }
 }

References DeoptimizeMarkedCodeForContext(), function(), v8::internal::Code::kind(), and v8::internal::Code::set_marked_for_deoptimization().

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeoptimizeGlobalObject()

void v8::internal::Deoptimizer::DeoptimizeGlobalObject ( JSObject * object )

static

Definition at line 470 of file deoptimizer.cc.

                                                          {
   if (FLAG_trace_deopt) {
     CodeTracer::Scope scope(object->GetHeap()->isolate()->GetCodeTracer());
     PrintF(scope.file(), "[deoptimize global object @ 0x%08" V8PRIxPTR "]\n",
         reinterpret_cast<intptr_t>(object));
   }
   if (object->IsJSGlobalProxy()) {
     PrototypeIterator iter(object->GetIsolate(), object);
     // TODO(verwaest): This CHECK will be hit if the global proxy is detached.
     CHECK(iter.GetCurrent()->IsJSGlobalObject());
     Context* native_context =
         GlobalObject::cast(iter.GetCurrent())->native_context();
     MarkAllCodeForContext(native_context);
     DeoptimizeMarkedCodeForContext(native_context);
   } else if (object->IsGlobalObject()) {
     Context* native_context = GlobalObject::cast(object)->native_context();
     MarkAllCodeForContext(native_context);
     DeoptimizeMarkedCodeForContext(native_context);
   }
 }

References CHECK, DeoptimizeMarkedCodeForContext(), v8::internal::Isolate::GetCodeTracer(), v8::internal::PrototypeIterator::GetCurrent(), v8::internal::HeapObject::GetHeap(), v8::internal::HeapObject::GetIsolate(), v8::internal::Heap::isolate(), MarkAllCodeForContext(), v8::internal::Context::native_context(), v8::internal::PrintF(), and V8PRIxPTR.

Referenced by v8::internal::JSObject::SetPropertyCallback(), and v8::Object::TurnOnAccessCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeoptimizeMarkedCode()

void v8::internal::Deoptimizer::DeoptimizeMarkedCode ( Isolate * isolate )

static

Definition at line 454 of file deoptimizer.cc.

                                                        {
   if (FLAG_trace_deopt) {
     CodeTracer::Scope scope(isolate->GetCodeTracer());
     PrintF(scope.file(), "[deoptimize marked code in all contexts]\n");
   }
   DisallowHeapAllocation no_allocation;
   // For all contexts, deoptimize code already marked.
   Object* context = isolate->heap()->native_contexts_list();
   while (!context->IsUndefined()) {
     Context* native_context = Context::cast(context);
     DeoptimizeMarkedCodeForContext(native_context);
     context = native_context->get(Context::NEXT_CONTEXT_LINK);
   }
 }

References v8::internal::Context::cast(), DeoptimizeMarkedCodeForContext(), v8::internal::FixedArray::get(), v8::internal::Isolate::GetCodeTracer(), v8::internal::Isolate::heap(), isolate(), v8::internal::Heap::native_contexts_list(), v8::internal::Context::NEXT_CONTEXT_LINK, and v8::internal::PrintF().

Referenced by v8::internal::DependentCode::DeoptimizeDependentCodeGroup(), v8::internal::DeoptimizeDependentFunctions(), v8::internal::Heap::DeoptMarkedAllocationSites(), and v8::internal::MarkCompactCollector::Finish().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeoptimizeMarkedCodeForContext()

void v8::internal::Deoptimizer::DeoptimizeMarkedCodeForContext ( Context * native_context )

staticprivate

Definition at line 301 of file deoptimizer.cc.

                                                                  {
   DisallowHeapAllocation no_allocation;
  
   // A "closure" that unlinks optimized code that is going to be
   // deoptimized from the functions that refer to it.
   class SelectedCodeUnlinker: public OptimizedFunctionVisitor {
    public:
     virtual void EnterContext(Context* context) { }  // Don't care.
     virtual void LeaveContext(Context* context)  { }  // Don't care.
     virtual void VisitFunction(JSFunction* function) {
       Code* code = function->code();
       if (!code->marked_for_deoptimization()) return;
  
       // Unlink this function and evict from optimized code map.
       SharedFunctionInfo* shared = function->shared();
       function->set_code(shared->code());
  
       if (FLAG_trace_deopt) {
         CodeTracer::Scope scope(code->GetHeap()->isolate()->GetCodeTracer());
         PrintF(scope.file(), "[deoptimizer unlinked: ");
         function->PrintName(scope.file());
         PrintF(scope.file(),
                " / %" V8PRIxPTR "]\n", reinterpret_cast<intptr_t>(function));
       }
     }
   };
  
   // Unlink all functions that refer to marked code.
   SelectedCodeUnlinker unlinker;
   VisitAllOptimizedFunctionsForContext(context, &unlinker);
  
   Isolate* isolate = context->GetHeap()->isolate();
 #ifdef DEBUG
   Code* topmost_optimized_code = NULL;
   bool safe_to_deopt_topmost_optimized_code = false;
   // Make sure all activations of optimized code can deopt at their current PC.
   // The topmost optimized code has special handling because it cannot be
   // deoptimized due to weak object dependency.
   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 (FLAG_trace_deopt) {
         JSFunction* function =
             static_cast<OptimizedFrame*>(it.frame())->function();
         CodeTracer::Scope scope(isolate->GetCodeTracer());
         PrintF(scope.file(), "[deoptimizer found activation of function: ");
         function->PrintName(scope.file());
         PrintF(scope.file(),
                " / %" V8PRIxPTR "]\n", reinterpret_cast<intptr_t>(function));
       }
       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() && !FLAG_turbo_deoptimization;
       bool safe_to_deopt =
           deopt_index != Safepoint::kNoDeoptimizationIndex || turbofanned;
       CHECK(topmost_optimized_code == NULL || safe_to_deopt || turbofanned);
       if (topmost_optimized_code == NULL) {
         topmost_optimized_code = code;
         safe_to_deopt_topmost_optimized_code = safe_to_deopt;
       }
     }
   }
 #endif
  
   // Move marked code from the optimized code list to the deoptimized
   // code list, collecting them into a ZoneList.
   Zone zone(isolate);
   ZoneList<Code*> codes(10, &zone);
  
   // Walk over all optimized code objects in this native context.
   Code* prev = NULL;
   Object* element = context->OptimizedCodeListHead();
   while (!element->IsUndefined()) {
     Code* code = Code::cast(element);
     CHECK_EQ(code->kind(), Code::OPTIMIZED_FUNCTION);
     Object* next = code->next_code_link();
  
     if (code->marked_for_deoptimization() &&
         (!code->is_turbofanned() || FLAG_turbo_deoptimization)) {
       // Put the code into the list for later patching.
       codes.Add(code, &zone);
  
       if (prev != NULL) {
         // Skip this code in the optimized code list.
         prev->set_next_code_link(next);
       } else {
         // There was no previous node, the next node is the new head.
         context->SetOptimizedCodeListHead(next);
       }
  
       // Move the code to the _deoptimized_ code list.
       code->set_next_code_link(context->DeoptimizedCodeListHead());
       context->SetDeoptimizedCodeListHead(code);
     } else {
       // Not marked; preserve this element.
       prev = code;
     }
     element = next;
   }
  
   // TODO(titzer): we need a handle scope only because of the macro assembler,
   // which is only used in EnsureCodeForDeoptimizationEntry.
   HandleScope scope(isolate);
  
   // Now patch all the codes for deoptimization.
   for (int i = 0; i < codes.length(); i++) {
 #ifdef DEBUG
     if (codes[i] == topmost_optimized_code) {
       DCHECK(safe_to_deopt_topmost_optimized_code);
     }
 #endif
     // It is finally time to die, code object.
  
     // Remove the code from optimized code map.
     DeoptimizationInputData* deopt_data =
         DeoptimizationInputData::cast(codes[i]->deoptimization_data());
     SharedFunctionInfo* shared =
         SharedFunctionInfo::cast(deopt_data->SharedFunctionInfo());
     shared->EvictFromOptimizedCodeMap(codes[i], "deoptimized code");
  
     // Do platform-specific patching to force any activations to lazy deopt.
     if (!codes[i]->is_turbofanned() || FLAG_turbo_deoptimization) {
       PatchCodeForDeoptimization(isolate, codes[i]);
  
       // We might be in the middle of incremental marking with compaction.
       // Tell collector to treat this code object in a special way and
       // ignore all slots that might have been recorded on it.
       isolate->heap()->mark_compact_collector()->InvalidateCode(codes[i]);
     }
   }
 }

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::StackFrameIterator::Advance(), CHECK, CHECK_EQ, DCHECK, v8::internal::Context::DeoptimizedCodeListHead(), v8::internal::SharedFunctionInfo::EvictFromOptimizedCodeMap(), v8::internal::Isolate::GetCodeTracer(), v8::internal::HeapObject::GetHeap(), v8::internal::Code::GetSafepointEntry(), v8::internal::Isolate::heap(), v8::internal::MarkCompactCollector::InvalidateCode(), v8::internal::Code::is_turbofanned(), v8::internal::Heap::isolate(), isolate(), v8::internal::Code::kind(), v8::internal::Heap::mark_compact_collector(), v8::internal::Code::marked_for_deoptimization(), NULL, v8::internal::Context::OptimizedCodeListHead(), PatchCodeForDeoptimization(), v8::internal::PrintF(), v8::internal::Context::SetDeoptimizedCodeListHead(), v8::internal::Context::SetOptimizedCodeListHead(), v8::internal::Isolate::thread_local_top(), V8PRIxPTR, and VisitAllOptimizedFunctionsForContext().

Referenced by DeoptimizeAll(), DeoptimizeFunction(), DeoptimizeGlobalObject(), and DeoptimizeMarkedCode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoComputeAccessorStubFrame()

void v8::internal::Deoptimizer::DoComputeAccessorStubFrame	(	TranslationIterator *	iterator,
		int	frame_index,
		bool	is_setter_stub_frame
	)

private

Definition at line 1405 of file deoptimizer.cc.

                                                                         {
   JSFunction* accessor = JSFunction::cast(ComputeLiteral(iterator->Next()));
   // The receiver (and the implicit return value, if any) are expected in
   // registers by the LoadIC/StoreIC, so they don't belong to the output stack
   // frame. This means that we have to use a height of 0.
   unsigned height = 0;
   unsigned height_in_bytes = height * kPointerSize;
   const char* kind = is_setter_stub_frame ? "setter" : "getter";
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "  translating %s stub => height=%u\n", kind, height_in_bytes);
   }
  
   // We need 1 stack entry for the return address and enough entries for the
   // StackFrame::INTERNAL (FP, context, frame type, code object and constant
   // pool (if FLAG_enable_ool_constant_pool)- see MacroAssembler::EnterFrame).
   // For a setter stub frame we need one additional entry for the implicit
   // return value, see StoreStubCompiler::CompileStoreViaSetter.
   unsigned fixed_frame_entries =
       (StandardFrameConstants::kFixedFrameSize / kPointerSize) + 1 +
       (is_setter_stub_frame ? 1 : 0);
   unsigned fixed_frame_size = fixed_frame_entries * kPointerSize;
   unsigned output_frame_size = height_in_bytes + fixed_frame_size;
  
   // Allocate and store the output frame description.
   FrameDescription* output_frame =
       new(output_frame_size) FrameDescription(output_frame_size, accessor);
   output_frame->SetFrameType(StackFrame::INTERNAL);
  
   // A frame for an accessor stub can not be the topmost or bottommost one.
   CHECK(frame_index > 0 && frame_index < output_count_ - 1);
   CHECK_EQ(output_[frame_index], NULL);
   output_[frame_index] = output_frame;
  
   // The top address of the frame is computed from the previous frame's top and
   // this frame's size.
   intptr_t top_address = output_[frame_index - 1]->GetTop() - output_frame_size;
   output_frame->SetTop(top_address);
  
   unsigned output_offset = output_frame_size;
  
   // Read caller's PC from the previous frame.
   output_offset -= kPCOnStackSize;
   intptr_t callers_pc = output_[frame_index - 1]->GetPc();
   output_frame->SetCallerPc(output_offset, callers_pc);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %u] <- 0x%08" V8PRIxPTR
            " ; caller's pc\n",
            top_address + output_offset, output_offset, callers_pc);
   }
  
   // Read caller's FP from the previous frame, and set this frame's FP.
   output_offset -= kFPOnStackSize;
   intptr_t value = output_[frame_index - 1]->GetFp();
   output_frame->SetCallerFp(output_offset, value);
   intptr_t fp_value = top_address + output_offset;
   output_frame->SetFp(fp_value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %u] <- 0x%08" V8PRIxPTR
            " ; caller's fp\n",
            fp_value, output_offset, value);
   }
  
   if (FLAG_enable_ool_constant_pool) {
     // Read the caller's constant pool from the previous frame.
     output_offset -= kPointerSize;
     value = output_[frame_index - 1]->GetConstantPool();
     output_frame->SetCallerConstantPool(output_offset, value);
     if (trace_scope_) {
       PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
              V8PRIxPTR " ; caller's constant pool\n",
              top_address + output_offset, output_offset, value);
     }
   }
  
   // The context can be gotten from the previous frame.
   output_offset -= kPointerSize;
   value = output_[frame_index - 1]->GetContext();
   output_frame->SetFrameSlot(output_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %u] <- 0x%08" V8PRIxPTR
            " ; context\n",
            top_address + output_offset, output_offset, value);
   }
  
   // A marker value is used in place of the function.
   output_offset -= kPointerSize;
   value = reinterpret_cast<intptr_t>(Smi::FromInt(StackFrame::INTERNAL));
   output_frame->SetFrameSlot(output_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %u] <- 0x%08" V8PRIxPTR
            " ; function (%s sentinel)\n",
            top_address + output_offset, output_offset, value, kind);
   }
  
   // Get Code object from accessor stub.
   output_offset -= kPointerSize;
   Builtins::Name name = is_setter_stub_frame ?
       Builtins::kStoreIC_Setter_ForDeopt :
       Builtins::kLoadIC_Getter_ForDeopt;
   Code* accessor_stub = isolate_->builtins()->builtin(name);
   value = reinterpret_cast<intptr_t>(accessor_stub);
   output_frame->SetFrameSlot(output_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %u] <- 0x%08" V8PRIxPTR
            " ; code object\n",
            top_address + output_offset, output_offset, value);
   }
  
   // Skip receiver.
   DoTranslateObjectAndSkip(iterator);
  
   if (is_setter_stub_frame) {
     // The implicit return value was part of the artificial setter stub
     // environment.
     output_offset -= kPointerSize;
     DoTranslateCommand(iterator, frame_index, output_offset);
   }
  
   CHECK_EQ(output_offset, 0);
  
   Smi* offset = is_setter_stub_frame ?
       isolate_->heap()->setter_stub_deopt_pc_offset() :
       isolate_->heap()->getter_stub_deopt_pc_offset();
   intptr_t pc = reinterpret_cast<intptr_t>(
       accessor_stub->instruction_start() + offset->value());
   output_frame->SetPc(pc);
   if (FLAG_enable_ool_constant_pool) {
     intptr_t constant_pool_value =
         reinterpret_cast<intptr_t>(accessor_stub->constant_pool());
     output_frame->SetConstantPool(constant_pool_value);
   }
 }

Referenced by DoComputeOutputFrames().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoComputeArgumentsAdaptorFrame()

void v8::internal::Deoptimizer::DoComputeArgumentsAdaptorFrame	(	TranslationIterator *	iterator,
		int	frame_index
	)

private

Definition at line 1114 of file deoptimizer.cc.

                                                                   {
   JSFunction* function = JSFunction::cast(ComputeLiteral(iterator->Next()));
   unsigned height = iterator->Next();
   unsigned height_in_bytes = height * kPointerSize;
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "  translating arguments adaptor => height=%d\n", height_in_bytes);
   }
  
   unsigned fixed_frame_size = ArgumentsAdaptorFrameConstants::kFrameSize;
   unsigned output_frame_size = height_in_bytes + fixed_frame_size;
  
   // Allocate and store the output frame description.
   FrameDescription* output_frame =
       new(output_frame_size) FrameDescription(output_frame_size, function);
   output_frame->SetFrameType(StackFrame::ARGUMENTS_ADAPTOR);
  
   // Arguments adaptor can not be topmost or bottommost.
   CHECK(frame_index > 0 && frame_index < output_count_ - 1);
   CHECK(output_[frame_index] == NULL);
   output_[frame_index] = output_frame;
  
   // The top address of the frame is computed from the previous
   // frame's top and this frame's size.
   intptr_t top_address;
   top_address = output_[frame_index - 1]->GetTop() - output_frame_size;
   output_frame->SetTop(top_address);
  
   // Compute the incoming parameter translation.
   int parameter_count = height;
   unsigned output_offset = output_frame_size;
   for (int i = 0; i < parameter_count; ++i) {
     output_offset -= kPointerSize;
     DoTranslateCommand(iterator, frame_index, output_offset);
   }
  
   // Read caller's PC from the previous frame.
   output_offset -= kPCOnStackSize;
   intptr_t callers_pc = output_[frame_index - 1]->GetPc();
   output_frame->SetCallerPc(output_offset, callers_pc);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; caller's pc\n",
            top_address + output_offset, output_offset, callers_pc);
   }
  
   // Read caller's FP from the previous frame, and set this frame's FP.
   output_offset -= kFPOnStackSize;
   intptr_t value = output_[frame_index - 1]->GetFp();
   output_frame->SetCallerFp(output_offset, value);
   intptr_t fp_value = top_address + output_offset;
   output_frame->SetFp(fp_value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; caller's fp\n",
            fp_value, output_offset, value);
   }
  
   if (FLAG_enable_ool_constant_pool) {
     // Read the caller's constant pool from the previous frame.
     output_offset -= kPointerSize;
     value = output_[frame_index - 1]->GetConstantPool();
     output_frame->SetCallerConstantPool(output_offset, value);
     if (trace_scope_) {
       PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
              V8PRIxPTR "; caller's constant_pool\n",
              top_address + output_offset, output_offset, value);
     }
   }
  
   // A marker value is used in place of the context.
   output_offset -= kPointerSize;
   intptr_t context = reinterpret_cast<intptr_t>(
       Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
   output_frame->SetFrameSlot(output_offset, context);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; context (adaptor sentinel)\n",
            top_address + output_offset, output_offset, context);
   }
  
   // The function was mentioned explicitly in the ARGUMENTS_ADAPTOR_FRAME.
   output_offset -= kPointerSize;
   value = reinterpret_cast<intptr_t>(function);
   output_frame->SetFrameSlot(output_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; function\n",
            top_address + output_offset, output_offset, value);
   }
  
   // Number of incoming arguments.
   output_offset -= kPointerSize;
   value = reinterpret_cast<intptr_t>(Smi::FromInt(height - 1));
   output_frame->SetFrameSlot(output_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; argc (%d)\n",
            top_address + output_offset, output_offset, value, height - 1);
   }
  
   DCHECK(0 == output_offset);
  
   Builtins* builtins = isolate_->builtins();
   Code* adaptor_trampoline =
       builtins->builtin(Builtins::kArgumentsAdaptorTrampoline);
   intptr_t pc_value = reinterpret_cast<intptr_t>(
       adaptor_trampoline->instruction_start() +
       isolate_->heap()->arguments_adaptor_deopt_pc_offset()->value());
   output_frame->SetPc(pc_value);
   if (FLAG_enable_ool_constant_pool) {
     intptr_t constant_pool_value =
         reinterpret_cast<intptr_t>(adaptor_trampoline->constant_pool());
     output_frame->SetConstantPool(constant_pool_value);
   }
 }

Referenced by DoComputeOutputFrames().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoComputeCompiledStubFrame()

void v8::internal::Deoptimizer::DoComputeCompiledStubFrame	(	TranslationIterator *	iterator,
		int	frame_index
	)

private

Definition at line 1547 of file deoptimizer.cc.

                                                               {
   //
   //               FROM                                  TO
   //    |          ....           |          |          ....           |
   //    +-------------------------+          +-------------------------+
   //    | JSFunction continuation |          | JSFunction continuation |
   //    +-------------------------+          +-------------------------+
   // |  |    saved frame (FP)     |          |    saved frame (FP)     |
   // |  +=========================+<-fpreg   +=========================+<-fpreg
   // |  |constant pool (if ool_cp)|          |constant pool (if ool_cp)|
   // |  +-------------------------+          +-------------------------|
   // |  |   JSFunction context    |          |   JSFunction context    |
   // v  +-------------------------+          +-------------------------|
   //    |   COMPILED_STUB marker  |          |   STUB_FAILURE marker   |
   //    +-------------------------+          +-------------------------+
   //    |                         |          |  caller args.arguments_ |
   //    | ...                     |          +-------------------------+
   //    |                         |          |  caller args.length_    |
   //    |-------------------------|<-spreg   +-------------------------+
   //                                         |  caller args pointer    |
   //                                         +-------------------------+
   //                                         |  caller stack param 1   |
   //      parameters in registers            +-------------------------+
   //       and spilled to stack              |           ....          |
   //                                         +-------------------------+
   //                                         |  caller stack param n   |
   //                                         +-------------------------+<-spreg
   //                                         reg = number of parameters
   //                                         reg = failure handler address
   //                                         reg = saved frame
   //                                         reg = JSFunction context
   //
  
   CHECK(compiled_code_->is_hydrogen_stub());
   int major_key = CodeStub::GetMajorKey(compiled_code_);
   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();
   CHECK_GE(param_count, 0);
  
   int height_in_bytes = kPointerSize * param_count + sizeof(Arguments) +
       kPointerSize;
   int fixed_frame_size = StandardFrameConstants::kFixedFrameSize;
   int input_frame_size = input_->GetFrameSize();
   int output_frame_size = height_in_bytes + fixed_frame_size;
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "  translating %s => StubFailureTrampolineStub, height=%d\n",
            CodeStub::MajorName(static_cast<CodeStub::Major>(major_key), false),
            height_in_bytes);
   }
  
   // The stub failure trampoline is a single frame.
   FrameDescription* output_frame =
       new(output_frame_size) FrameDescription(output_frame_size, NULL);
   output_frame->SetFrameType(StackFrame::STUB_FAILURE_TRAMPOLINE);
   CHECK_EQ(frame_index, 0);
   output_[frame_index] = output_frame;
  
   // The top address for the output frame can be computed from the input
   // frame pointer and the output frame's height. Subtract space for the
   // context and function slots.
   Register fp_reg = StubFailureTrampolineFrame::fp_register();
   intptr_t top_address = input_->GetRegister(fp_reg.code()) -
       StandardFrameConstants::kFixedFrameSizeFromFp - height_in_bytes;
   output_frame->SetTop(top_address);
  
   // Read caller's PC (JSFunction continuation) from the input frame.
   unsigned input_frame_offset = input_frame_size - kPCOnStackSize;
   unsigned output_frame_offset = output_frame_size - kFPOnStackSize;
   intptr_t value = input_->GetFrameSlot(input_frame_offset);
   output_frame->SetCallerPc(output_frame_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; caller's pc\n",
            top_address + output_frame_offset, output_frame_offset, value);
   }
  
   // Read caller's FP from the input frame, and set this frame's FP.
   input_frame_offset -= kFPOnStackSize;
   value = input_->GetFrameSlot(input_frame_offset);
   output_frame_offset -= kFPOnStackSize;
   output_frame->SetCallerFp(output_frame_offset, value);
   intptr_t frame_ptr = input_->GetRegister(fp_reg.code());
   output_frame->SetRegister(fp_reg.code(), frame_ptr);
   output_frame->SetFp(frame_ptr);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; caller's fp\n",
            top_address + output_frame_offset, output_frame_offset, value);
   }
  
   if (FLAG_enable_ool_constant_pool) {
     // Read the caller's constant pool from the input frame.
     input_frame_offset -= kPointerSize;
     value = input_->GetFrameSlot(input_frame_offset);
     output_frame_offset -= kPointerSize;
     output_frame->SetCallerConstantPool(output_frame_offset, value);
     if (trace_scope_) {
       PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
              V8PRIxPTR " ; caller's constant_pool\n",
              top_address + output_frame_offset, output_frame_offset, value);
     }
   }
  
   // The context can be gotten from the input frame.
   Register context_reg = StubFailureTrampolineFrame::context_register();
   input_frame_offset -= kPointerSize;
   value = input_->GetFrameSlot(input_frame_offset);
   output_frame->SetRegister(context_reg.code(), value);
   output_frame_offset -= kPointerSize;
   output_frame->SetFrameSlot(output_frame_offset, value);
   CHECK(reinterpret_cast<Object*>(value)->IsContext());
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; context\n",
            top_address + output_frame_offset, output_frame_offset, value);
   }
  
   // A marker value is used in place of the function.
   output_frame_offset -= kPointerSize;
   value = reinterpret_cast<intptr_t>(
       Smi::FromInt(StackFrame::STUB_FAILURE_TRAMPOLINE));
   output_frame->SetFrameSlot(output_frame_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; function (stub failure sentinel)\n",
            top_address + output_frame_offset, output_frame_offset, value);
   }
  
   intptr_t caller_arg_count = 0;
   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;
   int args_arguments_offset = output_frame_offset;
   intptr_t the_hole = reinterpret_cast<intptr_t>(
       isolate_->heap()->the_hole_value());
   if (arg_count_known) {
     value = frame_ptr + StandardFrameConstants::kCallerSPOffset +
         (caller_arg_count - 1) * kPointerSize;
   } else {
     value = the_hole;
   }
  
   output_frame->SetFrameSlot(args_arguments_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; args.arguments %s\n",
            top_address + args_arguments_offset, args_arguments_offset, value,
            arg_count_known ? "" : "(the hole)");
   }
  
   output_frame_offset -= kPointerSize;
   int length_frame_offset = output_frame_offset;
   value = arg_count_known ? caller_arg_count : the_hole;
   output_frame->SetFrameSlot(length_frame_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; args.length %s\n",
            top_address + length_frame_offset, length_frame_offset, value,
            arg_count_known ? "" : "(the hole)");
   }
  
   output_frame_offset -= kPointerSize;
   value = frame_ptr + StandardFrameConstants::kCallerSPOffset -
       (output_frame_size - output_frame_offset) + kPointerSize;
   output_frame->SetFrameSlot(output_frame_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; args*\n",
            top_address + output_frame_offset, output_frame_offset, value);
   }
  
   // Copy the register parameters to the failure frame.
   int arguments_length_offset = -1;
   for (int i = 0; i < param_count; ++i) {
     output_frame_offset -= kPointerSize;
     DoTranslateCommand(iterator, 0, output_frame_offset);
  
     if (!arg_count_known && descriptor.IsEnvironmentParameterCountRegister(i)) {
       arguments_length_offset = output_frame_offset;
     }
   }
  
   CHECK_EQ(output_frame_offset, 0);
  
   if (!arg_count_known) {
     CHECK_GE(arguments_length_offset, 0);
     // We know it's a smi because 1) the code stub guarantees the stack
     // parameter count is in smi range, and 2) the DoTranslateCommand in the
     // parameter loop above translated that to a tagged value.
     Smi* smi_caller_arg_count = reinterpret_cast<Smi*>(
         output_frame->GetFrameSlot(arguments_length_offset));
     caller_arg_count = smi_caller_arg_count->value();
     output_frame->SetFrameSlot(length_frame_offset, caller_arg_count);
     if (trace_scope_ != NULL) {
       PrintF(trace_scope_->file(),
              "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
              V8PRIxPTR " ; args.length\n",
              top_address + length_frame_offset, length_frame_offset,
              caller_arg_count);
     }
     value = frame_ptr + StandardFrameConstants::kCallerSPOffset +
         (caller_arg_count - 1) * kPointerSize;
     output_frame->SetFrameSlot(args_arguments_offset, value);
     if (trace_scope_ != NULL) {
       PrintF(trace_scope_->file(),
              "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
              V8PRIxPTR " ; args.arguments\n",
              top_address + args_arguments_offset, args_arguments_offset,
              value);
     }
   }
  
   // Copy the double registers from the input into the output frame.
   CopyDoubleRegisters(output_frame);
  
   // Fill registers containing handler and number of parameters.
   SetPlatformCompiledStubRegisters(output_frame, &descriptor);
  
   // Compute this frame's PC, state, and continuation.
   Code* trampoline = NULL;
   StubFunctionMode function_mode = descriptor.function_mode();
   StubFailureTrampolineStub(isolate_,
                             function_mode).FindCodeInCache(&trampoline);
   DCHECK(trampoline != NULL);
   output_frame->SetPc(reinterpret_cast<intptr_t>(
       trampoline->instruction_start()));
   if (FLAG_enable_ool_constant_pool) {
     Register constant_pool_reg =
         StubFailureTrampolineFrame::constant_pool_pointer_register();
     intptr_t constant_pool_value =
         reinterpret_cast<intptr_t>(trampoline->constant_pool());
     output_frame->SetConstantPool(constant_pool_value);
     output_frame->SetRegister(constant_pool_reg.code(), constant_pool_value);
   }
   output_frame->SetState(Smi::FromInt(FullCodeGenerator::NO_REGISTERS));
   Code* notify_failure =
       isolate_->builtins()->builtin(Builtins::kNotifyStubFailureSaveDoubles);
   output_frame->SetContinuation(
       reinterpret_cast<intptr_t>(notify_failure->entry()));
 }

Referenced by DoComputeOutputFrames().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoComputeConstructStubFrame()

void v8::internal::Deoptimizer::DoComputeConstructStubFrame	(	TranslationIterator *	iterator,
		int	frame_index
	)

private

Definition at line 1238 of file deoptimizer.cc.

                                                                {
   Builtins* builtins = isolate_->builtins();
   Code* construct_stub = builtins->builtin(Builtins::kJSConstructStubGeneric);
   JSFunction* function = JSFunction::cast(ComputeLiteral(iterator->Next()));
   unsigned height = iterator->Next();
   unsigned height_in_bytes = height * kPointerSize;
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "  translating construct stub => height=%d\n", height_in_bytes);
   }
  
   unsigned fixed_frame_size = ConstructFrameConstants::kFrameSize;
   unsigned output_frame_size = height_in_bytes + fixed_frame_size;
  
   // Allocate and store the output frame description.
   FrameDescription* output_frame =
       new(output_frame_size) FrameDescription(output_frame_size, function);
   output_frame->SetFrameType(StackFrame::CONSTRUCT);
  
   // Construct stub can not be topmost or bottommost.
   DCHECK(frame_index > 0 && frame_index < output_count_ - 1);
   DCHECK(output_[frame_index] == NULL);
   output_[frame_index] = output_frame;
  
   // The top address of the frame is computed from the previous
   // frame's top and this frame's size.
   intptr_t top_address;
   top_address = output_[frame_index - 1]->GetTop() - output_frame_size;
   output_frame->SetTop(top_address);
  
   // Compute the incoming parameter translation.
   int parameter_count = height;
   unsigned output_offset = output_frame_size;
   for (int i = 0; i < parameter_count; ++i) {
     output_offset -= kPointerSize;
     int deferred_object_index = deferred_objects_.length();
     DoTranslateCommand(iterator, frame_index, output_offset);
     // The allocated receiver of a construct stub frame is passed as the
     // receiver parameter through the translation. It might be encoding
     // a captured object, patch the slot address for a captured object.
     if (i == 0 && deferred_objects_.length() > deferred_object_index) {
       CHECK(!deferred_objects_[deferred_object_index].is_arguments());
       deferred_objects_[deferred_object_index].patch_slot_address(top_address);
     }
   }
  
   // Read caller's PC from the previous frame.
   output_offset -= kPCOnStackSize;
   intptr_t callers_pc = output_[frame_index - 1]->GetPc();
   output_frame->SetCallerPc(output_offset, callers_pc);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; caller's pc\n",
            top_address + output_offset, output_offset, callers_pc);
   }
  
   // Read caller's FP from the previous frame, and set this frame's FP.
   output_offset -= kFPOnStackSize;
   intptr_t value = output_[frame_index - 1]->GetFp();
   output_frame->SetCallerFp(output_offset, value);
   intptr_t fp_value = top_address + output_offset;
   output_frame->SetFp(fp_value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; caller's fp\n",
            fp_value, output_offset, value);
   }
  
   if (FLAG_enable_ool_constant_pool) {
     // Read the caller's constant pool from the previous frame.
     output_offset -= kPointerSize;
     value = output_[frame_index - 1]->GetConstantPool();
     output_frame->SetCallerConstantPool(output_offset, value);
     if (trace_scope_) {
       PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
              V8PRIxPTR " ; caller's constant pool\n",
              top_address + output_offset, output_offset, value);
     }
   }
  
   // The context can be gotten from the previous frame.
   output_offset -= kPointerSize;
   value = output_[frame_index - 1]->GetContext();
   output_frame->SetFrameSlot(output_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; context\n",
            top_address + output_offset, output_offset, value);
   }
  
   // A marker value is used in place of the function.
   output_offset -= kPointerSize;
   value = reinterpret_cast<intptr_t>(Smi::FromInt(StackFrame::CONSTRUCT));
   output_frame->SetFrameSlot(output_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; function (construct sentinel)\n",
            top_address + output_offset, output_offset, value);
   }
  
   // The output frame reflects a JSConstructStubGeneric frame.
   output_offset -= kPointerSize;
   value = reinterpret_cast<intptr_t>(construct_stub);
   output_frame->SetFrameSlot(output_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; code object\n",
            top_address + output_offset, output_offset, value);
   }
  
   // Number of incoming arguments.
   output_offset -= kPointerSize;
   value = reinterpret_cast<intptr_t>(Smi::FromInt(height - 1));
   output_frame->SetFrameSlot(output_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; argc (%d)\n",
            top_address + output_offset, output_offset, value, height - 1);
   }
  
   // Constructor function being invoked by the stub (only present on some
   // architectures, indicated by kConstructorOffset).
   if (ConstructFrameConstants::kConstructorOffset != kMinInt) {
     output_offset -= kPointerSize;
     value = reinterpret_cast<intptr_t>(function);
     output_frame->SetFrameSlot(output_offset, value);
     if (trace_scope_ != NULL) {
       PrintF(trace_scope_->file(),
              "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
              V8PRIxPTR " ; constructor function\n",
              top_address + output_offset, output_offset, value);
     }
   }
  
   // The newly allocated object was passed as receiver in the artificial
   // constructor stub environment created by HEnvironment::CopyForInlining().
   output_offset -= kPointerSize;
   value = output_frame->GetFrameSlot(output_frame_size - kPointerSize);
   output_frame->SetFrameSlot(output_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; allocated receiver\n",
            top_address + output_offset, output_offset, value);
   }
  
   CHECK_EQ(0, output_offset);
  
   intptr_t pc = reinterpret_cast<intptr_t>(
       construct_stub->instruction_start() +
       isolate_->heap()->construct_stub_deopt_pc_offset()->value());
   output_frame->SetPc(pc);
   if (FLAG_enable_ool_constant_pool) {
     intptr_t constant_pool_value =
         reinterpret_cast<intptr_t>(construct_stub->constant_pool());
     output_frame->SetConstantPool(constant_pool_value);
   }
 }

Referenced by DoComputeOutputFrames().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoComputeJSFrame()

void v8::internal::Deoptimizer::DoComputeJSFrame	(	TranslationIterator *	iterator,
		int	frame_index
	)

private

Definition at line 875 of file deoptimizer.cc.

                                                     {
   BailoutId node_id = BailoutId(iterator->Next());
   JSFunction* function;
   if (frame_index != 0) {
     function = JSFunction::cast(ComputeLiteral(iterator->Next()));
   } else {
     int closure_id = iterator->Next();
     USE(closure_id);
     CHECK_EQ(Translation::kSelfLiteralId, closure_id);
     function = function_;
   }
   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 ");
     function->PrintName(trace_scope_->file());
     PrintF(trace_scope_->file(),
            " => node=%d, height=%d\n", node_id.ToInt(), height_in_bytes);
   }
  
   // The 'fixed' part of the frame consists of the incoming parameters and
   // the part described by JavaScriptFrameConstants.
   unsigned fixed_frame_size = ComputeFixedSize(function);
   unsigned input_frame_size = input_->GetFrameSize();
   unsigned output_frame_size = height_in_bytes + fixed_frame_size;
  
   // Allocate and store the output frame description.
   FrameDescription* output_frame =
       new(output_frame_size) FrameDescription(output_frame_size, function);
   output_frame->SetFrameType(StackFrame::JAVA_SCRIPT);
  
   bool is_bottommost = (0 == frame_index);
   bool is_topmost = (output_count_ - 1 == frame_index);
   CHECK(frame_index >= 0 && frame_index < output_count_);
   CHECK_EQ(output_[frame_index], NULL);
   output_[frame_index] = output_frame;
  
   // The top address for the bottommost output frame can be computed from
   // the input frame pointer and the output frame's height.  For all
   // subsequent output frames, it can be computed from the previous one's
   // top address and the current frame's size.
   Register fp_reg = JavaScriptFrame::fp_register();
   intptr_t top_address;
   if (is_bottommost) {
     // Determine whether the input frame contains alignment padding.
     has_alignment_padding_ =
         (!compiled_code_->is_turbofanned() && HasAlignmentPadding(function))
             ? 1
             : 0;
     // 2 = context and function in the frame.
     // If the optimized frame had alignment padding, adjust the frame pointer
     // to point to the new position of the old frame pointer after padding
     // is removed. Subtract 2 * kPointerSize for the context and function slots.
     top_address = input_->GetRegister(fp_reg.code()) -
         StandardFrameConstants::kFixedFrameSizeFromFp -
         height_in_bytes + has_alignment_padding_ * kPointerSize;
   } else {
     top_address = output_[frame_index - 1]->GetTop() - output_frame_size;
   }
   output_frame->SetTop(top_address);
  
   // Compute the incoming parameter translation.
   int parameter_count = function->shared()->formal_parameter_count() + 1;
   unsigned output_offset = output_frame_size;
   unsigned input_offset = input_frame_size;
   for (int i = 0; i < parameter_count; ++i) {
     output_offset -= kPointerSize;
     DoTranslateCommand(iterator, frame_index, output_offset);
   }
   input_offset -= (parameter_count * kPointerSize);
  
   // There are no translation commands for the caller's pc and fp, the
   // context, and the function.  Synthesize their values and set them up
   // explicitly.
   //
   // The caller's pc for the bottommost output frame is the same as in the
   // input frame.  For all subsequent output frames, it can be read from the
   // previous one.  This frame's pc can be computed from the non-optimized
   // function code and AST id of the bailout.
   output_offset -= kPCOnStackSize;
   input_offset -= kPCOnStackSize;
   intptr_t value;
   if (is_bottommost) {
     value = input_->GetFrameSlot(input_offset);
   } else {
     value = output_[frame_index - 1]->GetPc();
   }
   output_frame->SetCallerPc(output_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR  " ; caller's pc\n",
            top_address + output_offset, output_offset, value);
   }
  
   // The caller's frame pointer for the bottommost output frame is the same
   // as in the input frame.  For all subsequent output frames, it can be
   // read from the previous one.  Also compute and set this frame's frame
   // pointer.
   output_offset -= kFPOnStackSize;
   input_offset -= kFPOnStackSize;
   if (is_bottommost) {
     value = input_->GetFrameSlot(input_offset);
   } else {
     value = output_[frame_index - 1]->GetFp();
   }
   output_frame->SetCallerFp(output_offset, value);
   intptr_t fp_value = top_address + output_offset;
   DCHECK(!is_bottommost || (input_->GetRegister(fp_reg.code()) +
       has_alignment_padding_ * kPointerSize) == fp_value);
   output_frame->SetFp(fp_value);
   if (is_topmost) output_frame->SetRegister(fp_reg.code(), fp_value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR " ; caller's fp\n",
            fp_value, output_offset, value);
   }
   DCHECK(!is_bottommost || !has_alignment_padding_ ||
          (fp_value & kPointerSize) != 0);
  
   if (FLAG_enable_ool_constant_pool) {
     // For the bottommost output frame the constant pool pointer can be gotten
     // from the input frame. For subsequent output frames, it can be read from
     // the previous frame.
     output_offset -= kPointerSize;
     input_offset -= kPointerSize;
     if (is_bottommost) {
       value = input_->GetFrameSlot(input_offset);
     } else {
       value = output_[frame_index - 1]->GetConstantPool();
     }
     output_frame->SetCallerConstantPool(output_offset, value);
     if (trace_scope_) {
       PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
              V8PRIxPTR "; caller's constant_pool\n",
              top_address + output_offset, output_offset, value);
     }
   }
  
   // For the bottommost output frame the context can be gotten from the input
   // frame. For all subsequent output frames it can be gotten from the function
   // so long as we don't inline functions that need local contexts.
   Register context_reg = JavaScriptFrame::context_register();
   output_offset -= kPointerSize;
   input_offset -= kPointerSize;
   // 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->SetContext(value);
   if (is_topmost) output_frame->SetRegister(context_reg.code(), value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR "; context\n",
            top_address + output_offset, output_offset, value);
   }
  
   // The function was mentioned explicitly in the BEGIN_FRAME.
   output_offset -= kPointerSize;
   input_offset -= kPointerSize;
   value = reinterpret_cast<intptr_t>(function);
   // The function for the bottommost output frame should also agree with the
   // input frame.
   DCHECK(!is_bottommost || input_->GetFrameSlot(input_offset) == value);
   output_frame->SetFrameSlot(output_offset, value);
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08"
            V8PRIxPTR "; function\n",
            top_address + output_offset, output_offset, value);
   }
  
   // Translate the rest of the frame.
   for (unsigned i = 0; i < height; ++i) {
     output_offset -= kPointerSize;
     DoTranslateCommand(iterator, frame_index, output_offset);
   }
   CHECK_EQ(0, output_offset);
  
   // Compute this frame's PC, state, and continuation.
   Code* non_optimized_code = function->shared()->code();
   FixedArray* raw_data = non_optimized_code->deoptimization_data();
   DeoptimizationOutputData* data = DeoptimizationOutputData::cast(raw_data);
   Address start = non_optimized_code->instruction_start();
   unsigned pc_and_state = GetOutputInfo(data, node_id, function->shared());
   unsigned pc_offset = FullCodeGenerator::PcField::decode(pc_and_state);
   intptr_t pc_value = reinterpret_cast<intptr_t>(start + pc_offset);
   output_frame->SetPc(pc_value);
  
   // Update constant pool.
   if (FLAG_enable_ool_constant_pool) {
     intptr_t constant_pool_value =
         reinterpret_cast<intptr_t>(non_optimized_code->constant_pool());
     output_frame->SetConstantPool(constant_pool_value);
     if (is_topmost) {
       Register constant_pool_reg =
           JavaScriptFrame::constant_pool_pointer_register();
       output_frame->SetRegister(constant_pool_reg.code(), constant_pool_value);
     }
   }
  
   FullCodeGenerator::State state =
       FullCodeGenerator::StateField::decode(pc_and_state);
   output_frame->SetState(Smi::FromInt(state));
  
   // Set the continuation for the topmost frame.
   if (is_topmost && bailout_type_ != DEBUGGER) {
     Builtins* builtins = isolate_->builtins();
     Code* continuation = builtins->builtin(Builtins::kNotifyDeoptimized);
     if (bailout_type_ == LAZY) {
       continuation = builtins->builtin(Builtins::kNotifyLazyDeoptimized);
     } else if (bailout_type_ == SOFT) {
       continuation = builtins->builtin(Builtins::kNotifySoftDeoptimized);
     } else {
       CHECK_EQ(bailout_type_, EAGER);
     }
     output_frame->SetContinuation(
         reinterpret_cast<intptr_t>(continuation->entry()));
   }
 }

Referenced by DoComputeOutputFrames().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoComputeOutputFrames()

void v8::internal::Deoptimizer::DoComputeOutputFrames ( )

private

Definition at line 750 of file deoptimizer.cc.

                                         {
   // Print some helpful diagnostic information.
   if (FLAG_log_timer_events &&
       compiled_code_->kind() == Code::OPTIMIZED_FUNCTION) {
     LOG(isolate(), CodeDeoptEvent(compiled_code_));
   }
   base::ElapsedTimer timer;
  
   // Determine basic deoptimization information.  The optimized frame is
   // described by the input data.
   DeoptimizationInputData* input_data =
       DeoptimizationInputData::cast(compiled_code_->deoptimization_data());
  
   if (trace_scope_ != NULL) {
     timer.Start();
     PrintF(trace_scope_->file(),
            "[deoptimizing (DEOPT %s): begin 0x%08" V8PRIxPTR " ",
            MessageFor(bailout_type_),
            reinterpret_cast<intptr_t>(function_));
     PrintFunctionName();
     PrintF(trace_scope_->file(),
            " (opt #%d) @%d, FP to SP delta: %d]\n",
            input_data->OptimizationId()->value(),
            bailout_id_,
            fp_to_sp_delta_);
     if (bailout_type_ == EAGER || bailout_type_ == SOFT ||
         (compiled_code_->is_hydrogen_stub())) {
       compiled_code_->PrintDeoptLocation(trace_scope_->file(), bailout_id_);
     }
   }
  
   BailoutId node_id = input_data->AstId(bailout_id_);
   ByteArray* translations = input_data->TranslationByteArray();
   unsigned translation_index =
       input_data->TranslationIndex(bailout_id_)->value();
  
   // Do the input frame to output frame(s) translation.
   TranslationIterator iterator(translations, translation_index);
   Translation::Opcode opcode =
       static_cast<Translation::Opcode>(iterator.Next());
   DCHECK(Translation::BEGIN == opcode);
   USE(opcode);
   // Read the number of output frames and allocate an array for their
   // descriptions.
   int count = iterator.Next();
   iterator.Next();  // Drop JS frames count.
   DCHECK(output_ == NULL);
   output_ = new FrameDescription*[count];
   for (int i = 0; i < count; ++i) {
     output_[i] = NULL;
   }
   output_count_ = count;
  
   Register fp_reg = JavaScriptFrame::fp_register();
   stack_fp_ = reinterpret_cast<Address>(
       input_->GetRegister(fp_reg.code()) +
           has_alignment_padding_ * kPointerSize);
  
   // Translate each output frame.
   for (int i = 0; i < count; ++i) {
     // Read the ast node id, function, and frame height for this output frame.
     Translation::Opcode opcode =
         static_cast<Translation::Opcode>(iterator.Next());
     switch (opcode) {
       case Translation::JS_FRAME:
         DoComputeJSFrame(&iterator, i);
         jsframe_count_++;
         break;
       case Translation::ARGUMENTS_ADAPTOR_FRAME:
         DoComputeArgumentsAdaptorFrame(&iterator, i);
         break;
       case Translation::CONSTRUCT_STUB_FRAME:
         DoComputeConstructStubFrame(&iterator, i);
         break;
       case Translation::GETTER_STUB_FRAME:
         DoComputeAccessorStubFrame(&iterator, i, false);
         break;
       case Translation::SETTER_STUB_FRAME:
         DoComputeAccessorStubFrame(&iterator, i, true);
         break;
       case Translation::COMPILED_STUB_FRAME:
         DoComputeCompiledStubFrame(&iterator, i);
         break;
       case Translation::BEGIN:
       case Translation::REGISTER:
       case Translation::INT32_REGISTER:
       case Translation::UINT32_REGISTER:
       case Translation::DOUBLE_REGISTER:
       case Translation::STACK_SLOT:
       case Translation::INT32_STACK_SLOT:
       case Translation::UINT32_STACK_SLOT:
       case Translation::DOUBLE_STACK_SLOT:
       case Translation::LITERAL:
       case Translation::ARGUMENTS_OBJECT:
       default:
         FATAL("Unsupported translation");
         break;
     }
   }
  
   // Print some helpful diagnostic information.
   if (trace_scope_ != NULL) {
     double ms = timer.Elapsed().InMillisecondsF();
     int index = output_count_ - 1;  // Index of the topmost frame.
     JSFunction* function = output_[index]->GetFunction();
     PrintF(trace_scope_->file(),
            "[deoptimizing (%s): end 0x%08" V8PRIxPTR " ",
            MessageFor(bailout_type_),
            reinterpret_cast<intptr_t>(function));
     PrintFunctionName();
     PrintF(trace_scope_->file(),
            " @%d => node=%d, pc=0x%08" V8PRIxPTR ", state=%s, alignment=%s,"
            " took %0.3f ms]\n",
            bailout_id_,
            node_id.ToInt(),
            output_[index]->GetPc(),
            FullCodeGenerator::State2String(
                static_cast<FullCodeGenerator::State>(
                    output_[index]->GetState()->value())),
            has_alignment_padding_ ? "with padding" : "no padding",
            ms);
   }
 }

References v8::internal::DeoptimizationInputData::AstId(), bailout_id_, bailout_type_, v8::internal::Register::code(), compiled_code_, DCHECK, DoComputeAccessorStubFrame(), DoComputeArgumentsAdaptorFrame(), DoComputeCompiledStubFrame(), DoComputeConstructStubFrame(), DoComputeJSFrame(), EAGER, FATAL, v8::internal::JavaScriptFrame::fp_register(), fp_to_sp_delta_, function_, v8::internal::FrameDescription::GetFunction(), v8::internal::FrameDescription::GetPc(), v8::internal::FrameDescription::GetRegister(), v8::internal::FrameDescription::GetState(), has_alignment_padding_, input_, v8::internal::Code::is_hydrogen_stub(), isolate(), v8::internal::compiler::JS_FRAME, jsframe_count_, v8::internal::Code::kind(), v8::internal::kPointerSize, LOG, MessageFor(), NULL, output_, output_count_, v8::internal::Code::PrintDeoptLocation(), v8::internal::PrintF(), PrintFunctionName(), REGISTER, SOFT, stack_fp_, v8::internal::FullCodeGenerator::State2String(), v8::internal::BailoutId::ToInt(), trace_scope_, USE(), V8PRIxPTR, and v8::internal::Smi::value().

Referenced by ComputeOutputFrames().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoTranslateCommand()

void v8::internal::Deoptimizer::DoTranslateCommand	(	TranslationIterator *	iterator,
		int	frame_index,
		unsigned	output_offset
	)

private

Definition at line 2421 of file deoptimizer.cc.

                                                              {
   disasm::NameConverter converter;
   // A GC-safe temporary placeholder that we can put in the output frame.
   const intptr_t kPlaceholder = reinterpret_cast<intptr_t>(Smi::FromInt(0));
  
   Translation::Opcode opcode =
       static_cast<Translation::Opcode>(iterator->Next());
  
   switch (opcode) {
     case Translation::BEGIN:
     case Translation::JS_FRAME:
     case Translation::ARGUMENTS_ADAPTOR_FRAME:
     case Translation::CONSTRUCT_STUB_FRAME:
     case Translation::GETTER_STUB_FRAME:
     case Translation::SETTER_STUB_FRAME:
     case Translation::COMPILED_STUB_FRAME:
       FATAL("Unexpected translation opcode");
       return;
  
     case Translation::REGISTER: {
       int input_reg = iterator->Next();
       intptr_t input_value = input_->GetRegister(input_reg);
       if (trace_scope_ != NULL) {
         PrintF(
             trace_scope_->file(),
             "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08" V8PRIxPTR " ; %s ",
             output_[frame_index]->GetTop() + output_offset,
             output_offset,
             input_value,
             converter.NameOfCPURegister(input_reg));
         reinterpret_cast<Object*>(input_value)->ShortPrint(
             trace_scope_->file());
         PrintF(trace_scope_->file(), "\n");
       }
       output_[frame_index]->SetFrameSlot(output_offset, input_value);
       return;
     }
  
     case Translation::INT32_REGISTER: {
       int input_reg = iterator->Next();
       intptr_t value = input_->GetRegister(input_reg);
       bool is_smi = Smi::IsValid(value);
       if (trace_scope_ != NULL) {
         PrintF(
             trace_scope_->file(),
             "    0x%08" V8PRIxPTR ": [top + %d] <- %" V8PRIdPTR " ; %s (%s)\n",
             output_[frame_index]->GetTop() + output_offset,
             output_offset,
             value,
             converter.NameOfCPURegister(input_reg),
             TraceValueType(is_smi));
       }
       if (is_smi) {
         intptr_t tagged_value =
             reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value)));
         output_[frame_index]->SetFrameSlot(output_offset, tagged_value);
       } else {
         // We save the untagged value on the side and store a GC-safe
         // temporary placeholder in the frame.
         AddDoubleValue(output_[frame_index]->GetTop() + output_offset,
                        static_cast<double>(static_cast<int32_t>(value)));
         output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
       }
       return;
     }
  
     case Translation::UINT32_REGISTER: {
       int input_reg = iterator->Next();
       uintptr_t value = static_cast<uintptr_t>(input_->GetRegister(input_reg));
       bool is_smi = value <= static_cast<uintptr_t>(Smi::kMaxValue);
       if (trace_scope_ != NULL) {
         PrintF(
             trace_scope_->file(),
             "    0x%08" V8PRIxPTR ": [top + %d] <- %" V8PRIuPTR
             " ; uint %s (%s)\n",
             output_[frame_index]->GetTop() + output_offset,
             output_offset,
             value,
             converter.NameOfCPURegister(input_reg),
             TraceValueType(is_smi));
       }
       if (is_smi) {
         intptr_t tagged_value =
             reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value)));
         output_[frame_index]->SetFrameSlot(output_offset, tagged_value);
       } else {
         // We save the untagged value on the side and store a GC-safe
         // temporary placeholder in the frame.
         AddDoubleValue(output_[frame_index]->GetTop() + output_offset,
                        static_cast<double>(static_cast<uint32_t>(value)));
         output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
       }
       return;
     }
  
     case Translation::DOUBLE_REGISTER: {
       int input_reg = iterator->Next();
       double value = input_->GetDoubleRegister(input_reg);
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "    0x%08" V8PRIxPTR ": [top + %d] <- %e ; %s\n",
                output_[frame_index]->GetTop() + output_offset,
                output_offset,
                value,
                DoubleRegister::AllocationIndexToString(input_reg));
       }
       // We save the untagged value on the side and store a GC-safe
       // temporary placeholder in the frame.
       AddDoubleValue(output_[frame_index]->GetTop() + output_offset, value);
       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);
       intptr_t input_value = input_->GetFrameSlot(input_offset);
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "    0x%08" V8PRIxPTR ": ",
                output_[frame_index]->GetTop() + output_offset);
         PrintF(trace_scope_->file(),
                "[top + %d] <- 0x%08" V8PRIxPTR " ; [sp + %d] ",
                output_offset,
                input_value,
                input_offset);
         reinterpret_cast<Object*>(input_value)->ShortPrint(
             trace_scope_->file());
         PrintF(trace_scope_->file(), "\n");
       }
       output_[frame_index]->SetFrameSlot(output_offset, input_value);
       return;
     }
  
     case Translation::INT32_STACK_SLOT: {
       int input_slot_index = iterator->Next();
       unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
       intptr_t value = input_->GetFrameSlot(input_offset);
       bool is_smi = Smi::IsValid(value);
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "    0x%08" V8PRIxPTR ": ",
                output_[frame_index]->GetTop() + output_offset);
         PrintF(trace_scope_->file(),
                "[top + %d] <- %" V8PRIdPTR " ; [sp + %d] (%s)\n",
                output_offset,
                value,
                input_offset,
                TraceValueType(is_smi));
       }
       if (is_smi) {
         intptr_t tagged_value =
             reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value)));
         output_[frame_index]->SetFrameSlot(output_offset, tagged_value);
       } else {
         // We save the untagged value on the side and store a GC-safe
         // temporary placeholder in the frame.
         AddDoubleValue(output_[frame_index]->GetTop() + output_offset,
                        static_cast<double>(static_cast<int32_t>(value)));
         output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
       }
       return;
     }
  
     case Translation::UINT32_STACK_SLOT: {
       int input_slot_index = iterator->Next();
       unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
       uintptr_t value =
           static_cast<uintptr_t>(input_->GetFrameSlot(input_offset));
       bool is_smi = value <= static_cast<uintptr_t>(Smi::kMaxValue);
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "    0x%08" V8PRIxPTR ": ",
                output_[frame_index]->GetTop() + output_offset);
         PrintF(trace_scope_->file(),
                "[top + %d] <- %" V8PRIuPTR " ; [sp + %d] (uint32 %s)\n",
                output_offset,
                value,
                input_offset,
                TraceValueType(is_smi));
       }
       if (is_smi) {
         intptr_t tagged_value =
             reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value)));
         output_[frame_index]->SetFrameSlot(output_offset, tagged_value);
       } else {
         // We save the untagged value on the side and store a GC-safe
         // temporary placeholder in the frame.
         AddDoubleValue(output_[frame_index]->GetTop() + output_offset,
                        static_cast<double>(static_cast<uint32_t>(value)));
         output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
       }
       return;
     }
  
     case Translation::DOUBLE_STACK_SLOT: {
       int input_slot_index = iterator->Next();
       unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
       double value = input_->GetDoubleFrameSlot(input_offset);
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "    0x%08" V8PRIxPTR ": [top + %d] <- %e ; [sp + %d]\n",
                output_[frame_index]->GetTop() + output_offset,
                output_offset,
                value,
                input_offset);
       }
       // We save the untagged value on the side and store a GC-safe
       // temporary placeholder in the frame.
       AddDoubleValue(output_[frame_index]->GetTop() + output_offset, value);
       output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
       return;
     }
  
     case Translation::LITERAL: {
       Object* literal = ComputeLiteral(iterator->Next());
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "    0x%08" V8PRIxPTR ": [top + %d] <- ",
                output_[frame_index]->GetTop() + output_offset,
                output_offset);
         literal->ShortPrint(trace_scope_->file());
         PrintF(trace_scope_->file(), " ; literal\n");
       }
       intptr_t value = reinterpret_cast<intptr_t>(literal);
       output_[frame_index]->SetFrameSlot(output_offset, value);
       return;
     }
  
     case Translation::DUPLICATED_OBJECT: {
       int object_index = iterator->Next();
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "    0x%08" V8PRIxPTR ": [top + %d] <- ",
                output_[frame_index]->GetTop() + output_offset,
                output_offset);
         isolate_->heap()->arguments_marker()->ShortPrint(trace_scope_->file());
         PrintF(trace_scope_->file(),
                " ; duplicate of object #%d\n", object_index);
       }
       // Use the materialization marker value as a sentinel and fill in
       // the object after the deoptimized frame is built.
       intptr_t value = reinterpret_cast<intptr_t>(
           isolate_->heap()->arguments_marker());
       AddObjectDuplication(output_[frame_index]->GetTop() + output_offset,
                            object_index);
       output_[frame_index]->SetFrameSlot(output_offset, value);
       return;
     }
  
     case Translation::ARGUMENTS_OBJECT:
     case Translation::CAPTURED_OBJECT: {
       int length = iterator->Next();
       bool is_args = opcode == Translation::ARGUMENTS_OBJECT;
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "    0x%08" V8PRIxPTR ": [top + %d] <- ",
                output_[frame_index]->GetTop() + output_offset,
                output_offset);
         isolate_->heap()->arguments_marker()->ShortPrint(trace_scope_->file());
         PrintF(trace_scope_->file(),
                " ; object (length = %d, is_args = %d)\n", length, is_args);
       }
       // Use the materialization marker value as a sentinel and fill in
       // the object after the deoptimized frame is built.
       intptr_t value = reinterpret_cast<intptr_t>(
           isolate_->heap()->arguments_marker());
       AddObjectStart(output_[frame_index]->GetTop() + output_offset,
                      length, is_args);
       output_[frame_index]->SetFrameSlot(output_offset, value);
       // We save the object values on the side and materialize the actual
       // object after the deoptimized frame is built.
       int object_index = deferred_objects_.length() - 1;
       for (int i = 0; i < length; i++) {
         DoTranslateObject(iterator, object_index, i);
       }
       return;
     }
   }
 }

References AddDoubleValue(), AddObjectDuplication(), AddObjectStart(), v8::internal::DwVfpRegister::AllocationIndexToString(), ComputeLiteral(), deferred_objects_, DoTranslateObject(), FATAL, v8::internal::Smi::FromInt(), v8::internal::FrameDescription::GetDoubleFrameSlot(), v8::internal::FrameDescription::GetDoubleRegister(), v8::internal::FrameDescription::GetFrameSlot(), v8::internal::FrameDescription::GetOffsetFromSlotIndex(), v8::internal::FrameDescription::GetRegister(), v8::internal::FrameDescription::GetTop(), v8::internal::Isolate::heap(), input_, input_offset(), isolate_, v8::internal::Smi::IsValid(), v8::internal::compiler::JS_FRAME, v8::internal::Smi::kMaxValue, disasm::NameConverter::NameOfCPURegister(), NULL, output_, output_offset(), v8::internal::PrintF(), REGISTER, v8::internal::FrameDescription::SetFrameSlot(), v8::internal::Object::ShortPrint(), trace_scope_, v8::internal::TraceValueType(), V8PRIdPTR, V8PRIuPTR, and V8PRIxPTR.

Referenced by DoComputeAccessorStubFrame(), DoComputeArgumentsAdaptorFrame(), DoComputeCompiledStubFrame(), DoComputeConstructStubFrame(), and DoComputeJSFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoTranslateObject()

void v8::internal::Deoptimizer::DoTranslateObject	(	TranslationIterator *	iterator,
		int	object_index,
		int	field_index
	)

private

Definition at line 2159 of file deoptimizer.cc.

                                                      {
   disasm::NameConverter converter;
   Address object_slot = deferred_objects_[object_index].slot_address();
  
   Translation::Opcode opcode =
       static_cast<Translation::Opcode>(iterator->Next());
  
   switch (opcode) {
     case Translation::BEGIN:
     case Translation::JS_FRAME:
     case Translation::ARGUMENTS_ADAPTOR_FRAME:
     case Translation::CONSTRUCT_STUB_FRAME:
     case Translation::GETTER_STUB_FRAME:
     case Translation::SETTER_STUB_FRAME:
     case Translation::COMPILED_STUB_FRAME:
       FATAL("Unexpected frame start translation opcode");
       return;
  
     case Translation::REGISTER: {
       int input_reg = iterator->Next();
       intptr_t input_value = input_->GetRegister(input_reg);
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
                reinterpret_cast<intptr_t>(object_slot),
                field_index);
         PrintF(trace_scope_->file(),
                "0x%08" V8PRIxPTR " ; %s ", input_value,
                converter.NameOfCPURegister(input_reg));
         reinterpret_cast<Object*>(input_value)->ShortPrint(
             trace_scope_->file());
         PrintF(trace_scope_->file(),
                "\n");
       }
       AddObjectTaggedValue(input_value);
       return;
     }
  
     case Translation::INT32_REGISTER: {
       int input_reg = iterator->Next();
       intptr_t value = input_->GetRegister(input_reg);
       bool is_smi = Smi::IsValid(value);
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
                reinterpret_cast<intptr_t>(object_slot),
                field_index);
         PrintF(trace_scope_->file(),
                "%" V8PRIdPTR " ; %s (%s)\n", value,
                converter.NameOfCPURegister(input_reg),
                TraceValueType(is_smi));
       }
       if (is_smi) {
         intptr_t tagged_value =
             reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value)));
         AddObjectTaggedValue(tagged_value);
       } else {
         double double_value = static_cast<double>(static_cast<int32_t>(value));
         AddObjectDoubleValue(double_value);
       }
       return;
     }
  
     case Translation::UINT32_REGISTER: {
       int input_reg = iterator->Next();
       uintptr_t value = static_cast<uintptr_t>(input_->GetRegister(input_reg));
       bool is_smi = (value <= static_cast<uintptr_t>(Smi::kMaxValue));
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
                reinterpret_cast<intptr_t>(object_slot),
                field_index);
         PrintF(trace_scope_->file(),
                "%" V8PRIdPTR " ; uint %s (%s)\n", value,
                converter.NameOfCPURegister(input_reg),
                TraceValueType(is_smi));
       }
       if (is_smi) {
         intptr_t tagged_value =
             reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value)));
         AddObjectTaggedValue(tagged_value);
       } else {
         double double_value = static_cast<double>(static_cast<uint32_t>(value));
         AddObjectDoubleValue(double_value);
       }
       return;
     }
  
     case Translation::DOUBLE_REGISTER: {
       int input_reg = iterator->Next();
       double value = input_->GetDoubleRegister(input_reg);
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
                reinterpret_cast<intptr_t>(object_slot),
                field_index);
         PrintF(trace_scope_->file(),
                "%e ; %s\n", value,
                DoubleRegister::AllocationIndexToString(input_reg));
       }
       AddObjectDoubleValue(value);
       return;
     }
  
     case Translation::STACK_SLOT: {
       int input_slot_index = iterator->Next();
       unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
       intptr_t input_value = input_->GetFrameSlot(input_offset);
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
                reinterpret_cast<intptr_t>(object_slot),
                field_index);
         PrintF(trace_scope_->file(),
                "0x%08" V8PRIxPTR " ; [sp + %d] ", input_value, input_offset);
         reinterpret_cast<Object*>(input_value)->ShortPrint(
             trace_scope_->file());
         PrintF(trace_scope_->file(),
                "\n");
       }
       AddObjectTaggedValue(input_value);
       return;
     }
  
     case Translation::INT32_STACK_SLOT: {
       int input_slot_index = iterator->Next();
       unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
       intptr_t value = input_->GetFrameSlot(input_offset);
       bool is_smi = Smi::IsValid(value);
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
                reinterpret_cast<intptr_t>(object_slot),
                field_index);
         PrintF(trace_scope_->file(),
                "%" V8PRIdPTR " ; [sp + %d] (%s)\n",
                value, input_offset, TraceValueType(is_smi));
       }
       if (is_smi) {
         intptr_t tagged_value =
             reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value)));
         AddObjectTaggedValue(tagged_value);
       } else {
         double double_value = static_cast<double>(static_cast<int32_t>(value));
         AddObjectDoubleValue(double_value);
       }
       return;
     }
  
     case Translation::UINT32_STACK_SLOT: {
       int input_slot_index = iterator->Next();
       unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
       uintptr_t value =
           static_cast<uintptr_t>(input_->GetFrameSlot(input_offset));
       bool is_smi = (value <= static_cast<uintptr_t>(Smi::kMaxValue));
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
                reinterpret_cast<intptr_t>(object_slot),
                field_index);
         PrintF(trace_scope_->file(),
                "%" V8PRIdPTR " ; [sp + %d] (uint %s)\n",
                value, input_offset, TraceValueType(is_smi));
       }
       if (is_smi) {
         intptr_t tagged_value =
             reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value)));
         AddObjectTaggedValue(tagged_value);
       } else {
         double double_value = static_cast<double>(static_cast<uint32_t>(value));
         AddObjectDoubleValue(double_value);
       }
       return;
     }
  
     case Translation::DOUBLE_STACK_SLOT: {
       int input_slot_index = iterator->Next();
       unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index);
       double value = input_->GetDoubleFrameSlot(input_offset);
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
                reinterpret_cast<intptr_t>(object_slot),
                field_index);
         PrintF(trace_scope_->file(),
                "%e ; [sp + %d]\n", value, input_offset);
       }
       AddObjectDoubleValue(value);
       return;
     }
  
     case Translation::LITERAL: {
       Object* literal = ComputeLiteral(iterator->Next());
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "      object @0x%08" V8PRIxPTR ": [field #%d] <- ",
                reinterpret_cast<intptr_t>(object_slot),
                field_index);
         literal->ShortPrint(trace_scope_->file());
         PrintF(trace_scope_->file(),
                " ; literal\n");
       }
       intptr_t value = reinterpret_cast<intptr_t>(literal);
       AddObjectTaggedValue(value);
       return;
     }
  
     case Translation::DUPLICATED_OBJECT: {
       int object_index = iterator->Next();
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "      nested @0x%08" V8PRIxPTR ": [field #%d] <- ",
                reinterpret_cast<intptr_t>(object_slot),
                field_index);
         isolate_->heap()->arguments_marker()->ShortPrint(trace_scope_->file());
         PrintF(trace_scope_->file(),
                " ; duplicate of object #%d\n", object_index);
       }
       // Use the materialization marker value as a sentinel and fill in
       // the object after the deoptimized frame is built.
       intptr_t value = reinterpret_cast<intptr_t>(
           isolate_->heap()->arguments_marker());
       AddObjectDuplication(0, object_index);
       AddObjectTaggedValue(value);
       return;
     }
  
     case Translation::ARGUMENTS_OBJECT:
     case Translation::CAPTURED_OBJECT: {
       int length = iterator->Next();
       bool is_args = opcode == Translation::ARGUMENTS_OBJECT;
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "      nested @0x%08" V8PRIxPTR ": [field #%d] <- ",
                reinterpret_cast<intptr_t>(object_slot),
                field_index);
         isolate_->heap()->arguments_marker()->ShortPrint(trace_scope_->file());
         PrintF(trace_scope_->file(),
                " ; object (length = %d, is_args = %d)\n", length, is_args);
       }
       // Use the materialization marker value as a sentinel and fill in
       // the object after the deoptimized frame is built.
       intptr_t value = reinterpret_cast<intptr_t>(
           isolate_->heap()->arguments_marker());
       AddObjectStart(0, length, is_args);
       AddObjectTaggedValue(value);
       // We save the object values on the side and materialize the actual
       // object after the deoptimized frame is built.
       int object_index = deferred_objects_.length() - 1;
       for (int i = 0; i < length; i++) {
         DoTranslateObject(iterator, object_index, i);
       }
       return;
     }
   }
  
   FATAL("Unexpected translation opcode");
 }

References AddObjectDoubleValue(), AddObjectDuplication(), AddObjectStart(), AddObjectTaggedValue(), v8::internal::DwVfpRegister::AllocationIndexToString(), ComputeLiteral(), deferred_objects_, FATAL, v8::internal::Smi::FromInt(), v8::internal::FrameDescription::GetDoubleFrameSlot(), v8::internal::FrameDescription::GetDoubleRegister(), v8::internal::FrameDescription::GetFrameSlot(), v8::internal::FrameDescription::GetOffsetFromSlotIndex(), v8::internal::FrameDescription::GetRegister(), v8::internal::Isolate::heap(), input_, input_offset(), isolate_, v8::internal::Smi::IsValid(), v8::internal::compiler::JS_FRAME, v8::internal::Smi::kMaxValue, disasm::NameConverter::NameOfCPURegister(), NULL, v8::internal::PrintF(), REGISTER, v8::internal::Object::ShortPrint(), trace_scope_, v8::internal::TraceValueType(), V8PRIdPTR, and V8PRIxPTR.

Referenced by DoTranslateCommand(), and DoTranslateObjectAndSkip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoTranslateObjectAndSkip()

void v8::internal::Deoptimizer::DoTranslateObjectAndSkip ( TranslationIterator * iterator )

private

Definition at line 2092 of file deoptimizer.cc.

                                                                         {
   Translation::Opcode opcode =
       static_cast<Translation::Opcode>(iterator->Next());
  
   switch (opcode) {
     case Translation::BEGIN:
     case Translation::JS_FRAME:
     case Translation::ARGUMENTS_ADAPTOR_FRAME:
     case Translation::CONSTRUCT_STUB_FRAME:
     case Translation::GETTER_STUB_FRAME:
     case Translation::SETTER_STUB_FRAME:
     case Translation::COMPILED_STUB_FRAME: {
       FATAL("Unexpected frame start translation opcode");
       return;
     }
  
     case Translation::REGISTER:
     case Translation::INT32_REGISTER:
     case Translation::UINT32_REGISTER:
     case Translation::DOUBLE_REGISTER:
     case Translation::STACK_SLOT:
     case Translation::INT32_STACK_SLOT:
     case Translation::UINT32_STACK_SLOT:
     case Translation::DOUBLE_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::DUPLICATED_OBJECT: {
       int object_index = iterator->Next();
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(), "      skipping object ");
         PrintF(trace_scope_->file(),
                " ; duplicate of object #%d\n", object_index);
       }
       AddObjectDuplication(0, object_index);
       return;
     }
  
     case Translation::ARGUMENTS_OBJECT:
     case Translation::CAPTURED_OBJECT: {
       int length = iterator->Next();
       bool is_args = opcode == Translation::ARGUMENTS_OBJECT;
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(), "    skipping object ");
         PrintF(trace_scope_->file(),
                " ; object (length = %d, is_args = %d)\n", length, is_args);
       }
  
       AddObjectStart(0, length, is_args);
  
       // We save the object values on the side and materialize the actual
       // object after the deoptimized frame is built.
       int object_index = deferred_objects_.length() - 1;
       for (int i = 0; i < length; i++) {
         DoTranslateObject(iterator, object_index, i);
       }
       return;
     }
   }
  
   FATAL("Unexpected translation opcode");
 }

References AddObjectDuplication(), AddObjectStart(), deferred_objects_, DoTranslateObject(), FATAL, v8::internal::compiler::JS_FRAME, NULL, v8::internal::PrintF(), REGISTER, and trace_scope_.

Referenced by DoComputeAccessorStubFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EnsureCodeForDeoptimizationEntry()

void v8::internal::Deoptimizer::EnsureCodeForDeoptimizationEntry	(	Isolate *	isolate,
		BailoutType	type,
		int	max_entry_id
	)

static

Definition at line 2790 of file deoptimizer.cc.

                                                                      {
   // We cannot run this if the serializer is enabled because this will
   // cause us to emit relocation information for the external
   // references. This is fine because the deoptimizer's code section
   // isn't meant to be serialized at all.
   CHECK(type == EAGER || type == SOFT || type == LAZY);
   DeoptimizerData* data = isolate->deoptimizer_data();
   int entry_count = data->deopt_entry_code_entries_[type];
   if (max_entry_id < entry_count) return;
   entry_count = Max(entry_count, Deoptimizer::kMinNumberOfEntries);
   while (max_entry_id >= entry_count) entry_count *= 2;
   CHECK(entry_count <= Deoptimizer::kMaxNumberOfEntries);
  
   MacroAssembler masm(isolate, NULL, 16 * KB);
   masm.set_emit_debug_code(false);
   GenerateDeoptimizationEntries(&masm, entry_count, type);
   CodeDesc desc;
   masm.GetCode(&desc);
   DCHECK(!RelocInfo::RequiresRelocation(desc));
  
   MemoryChunk* chunk = data->deopt_entry_code_[type];
   CHECK(static_cast<int>(Deoptimizer::GetMaxDeoptTableSize()) >=
         desc.instr_size);
   chunk->CommitArea(desc.instr_size);
   CopyBytes(chunk->area_start(), desc.buffer,
       static_cast<size_t>(desc.instr_size));
   CpuFeatures::FlushICache(chunk->area_start(), desc.instr_size);
  
   data->deopt_entry_code_entries_[type] = entry_count;
 }

References v8::internal::MemoryChunk::area_start(), v8::internal::CodeDesc::buffer, CHECK, v8::internal::MemoryChunk::CommitArea(), v8::internal::CopyBytes(), DCHECK, v8::internal::DeoptimizerData::deopt_entry_code_, v8::internal::DeoptimizerData::deopt_entry_code_entries_, v8::internal::Isolate::deoptimizer_data(), EAGER, v8::internal::CpuFeatures::FlushICache(), GenerateDeoptimizationEntries(), v8::internal::Assembler::GetCode(), GetMaxDeoptTableSize(), v8::internal::CodeDesc::instr_size, isolate(), v8::internal::KB, kMaxNumberOfEntries, kMinNumberOfEntries, LAZY, v8::internal::Max(), NULL, v8::internal::AssemblerBase::set_emit_debug_code(), and SOFT.

Referenced by GetDeoptimizationEntry(), and v8::internal::Isolate::Init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EnsureRelocSpaceForLazyDeoptimization()

static void v8::internal::Deoptimizer::EnsureRelocSpaceForLazyDeoptimization ( Handle< Code > code )

static

◆ FillInputFrame()

void v8::internal::Deoptimizer::FillInputFrame	(	Address	tos,
		JavaScriptFrame *	frame
	)

private

Definition at line 82 of file deoptimizer-arm.cc.

                                                                     {
   // 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 fp and sp are set to the correct values though.
  
   for (int i = 0; i < Register::kNumRegisters; i++) {
     input_->SetRegister(i, i * 4);
   }
   input_->SetRegister(sp.code(), reinterpret_cast<intptr_t>(frame->sp()));
   input_->SetRegister(fp.code(), reinterpret_cast<intptr_t>(frame->fp()));
   for (int i = 0; i < DoubleRegister::NumAllocatableRegisters(); 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));
   }
 }

References v8::internal::Register::code(), v8::internal::fp, v8::internal::FrameDescription::GetFrameSize(), input_, v8::internal::Register::kNumRegisters, v8::internal::kPointerSize, v8::internal::DwVfpRegister::NumAllocatableRegisters(), v8::internal::FrameDescription::SetDoubleRegister(), v8::internal::FrameDescription::SetFrameSlot(), v8::internal::FrameDescription::SetRegister(), v8::internal::sp, and v8::internal::Memory::uint32_at().

Referenced by DebuggerInspectableFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindDeoptimizingCode()

Code * v8::internal::Deoptimizer::FindDeoptimizingCode ( Address addr )

private

Definition at line 60 of file deoptimizer.cc.

                                                     {
   if (function_->IsHeapObject()) {
     // Search all deoptimizing code in the native context of the function.
     Context* native_context = function_->context()->native_context();
     Object* element = native_context->DeoptimizedCodeListHead();
     while (!element->IsUndefined()) {
       Code* code = Code::cast(element);
       CHECK(code->kind() == Code::OPTIMIZED_FUNCTION);
       if (code->contains(addr)) return code;
       element = code->next_code_link();
     }
   }
   return NULL;
 }

References CHECK, v8::internal::Code::contains(), v8::internal::JSFunction::context(), v8::internal::Context::DeoptimizedCodeListHead(), function_, v8::internal::Code::kind(), v8::internal::Context::native_context(), and NULL.

Referenced by FindOptimizedCode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindOptimizedCode()

Code * v8::internal::Deoptimizer::FindOptimizedCode	(	JSFunction *	function,
		Code *	optimized_code
	)

private

Definition at line 618 of file deoptimizer.cc.

                                                            {
   switch (bailout_type_) {
     case Deoptimizer::SOFT:
     case Deoptimizer::EAGER:
     case Deoptimizer::LAZY: {
       Code* compiled_code = FindDeoptimizingCode(from_);
       return (compiled_code == NULL)
           ? static_cast<Code*>(isolate_->FindCodeObject(from_))
           : compiled_code;
     }
     case Deoptimizer::DEBUGGER:
       DCHECK(optimized_code->contains(from_));
       return optimized_code;
   }
   FATAL("Could not find code for optimized function");
   return NULL;
 }

References bailout_type_, compiled_code(), v8::internal::Code::contains(), DCHECK, DEBUGGER, EAGER, FATAL, v8::internal::Isolate::FindCodeObject(), FindDeoptimizingCode(), from_, isolate_, LAZY, NULL, and SOFT.

Referenced by Deoptimizer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ function()

Handle<JSFunction> v8::internal::Deoptimizer::function ( ) const

inline

Definition at line 149 of file deoptimizer.h.

149 { return Handle<JSFunction>(function_); }

References function_.

Referenced by ComputeIncomingArgumentSize(), DeoptimizeFunction(), Deoptimizer(), DoComputeJSFrame(), v8::internal::RUNTIME_FUNCTION(), and VisitAllOptimizedFunctionsForContext().

Here is the caller graph for this function:

◆ GenerateDeoptimizationEntries()

void v8::internal::Deoptimizer::GenerateDeoptimizationEntries	(	MacroAssembler *	masm,
		int	count,
		BailoutType	type
	)

staticprivate

Definition at line 232 of file deoptimizer.cc.

                                                                   {
   TableEntryGenerator generator(masm, type, count);
   generator.Generate();
 }

Referenced by EnsureCodeForDeoptimizationEntry().

Here is the caller graph for this function:

◆ GetDeoptimizationEntry()

Address v8::internal::Deoptimizer::GetDeoptimizationEntry	(	Isolate *	isolate,
		int	id,
		BailoutType	type,
		GetEntryMode	mode = `ENSURE_ENTRY_CODE`
	)

static

Definition at line 672 of file deoptimizer.cc.

                                                                {
   CHECK_GE(id, 0);
   if (id >= kMaxNumberOfEntries) return NULL;
   if (mode == ENSURE_ENTRY_CODE) {
     EnsureCodeForDeoptimizationEntry(isolate, type, id);
   } else {
     CHECK_EQ(mode, CALCULATE_ENTRY_ADDRESS);
   }
   DeoptimizerData* data = isolate->deoptimizer_data();
   CHECK_LT(type, kBailoutTypesWithCodeEntry);
   MemoryChunk* base = data->deopt_entry_code_[type];
   return base->area_start() + (id * table_entry_size_);
 }

References v8::internal::MemoryChunk::area_start(), CALCULATE_ENTRY_ADDRESS, CHECK_EQ, CHECK_GE, CHECK_LT, v8::internal::DeoptimizerData::deopt_entry_code_, v8::internal::Isolate::deoptimizer_data(), ENSURE_ENTRY_CODE, EnsureCodeForDeoptimizationEntry(), isolate(), kBailoutTypesWithCodeEntry, kMaxNumberOfEntries, mode(), NULL, and table_entry_size_.

Referenced by v8::internal::LCodeGen::DeoptimizeBranch(), v8::internal::LCodeGen::DeoptimizeIf(), PatchCodeForDeoptimization(), and v8::internal::ExternalReferenceTable::PopulateTable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetDeoptimizationId()

int v8::internal::Deoptimizer::GetDeoptimizationId	(	Isolate *	isolate,
		Address	addr,
		BailoutType	type
	)

static

Definition at line 690 of file deoptimizer.cc.

                                                        {
   DeoptimizerData* data = isolate->deoptimizer_data();
   MemoryChunk* base = data->deopt_entry_code_[type];
   Address start = base->area_start();
   if (base == NULL ||
       addr < start ||
       addr >= start + (kMaxNumberOfEntries * table_entry_size_)) {
     return kNotDeoptimizationEntry;
   }
   DCHECK_EQ(0,
             static_cast<int>(addr - start) % table_entry_size_);
   return static_cast<int>(addr - start) / table_entry_size_;
 }

References v8::internal::MemoryChunk::area_start(), DCHECK_EQ, v8::internal::DeoptimizerData::deopt_entry_code_, v8::internal::Isolate::deoptimizer_data(), isolate(), kMaxNumberOfEntries, kNotDeoptimizationEntry, NULL, and table_entry_size_.

Referenced by v8::internal::Code::PrintDeoptLocation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetDeoptimizedCodeCount()

int v8::internal::Deoptimizer::GetDeoptimizedCodeCount ( Isolate * isolate )

static

Definition at line 729 of file deoptimizer.cc.

                                                          {
   int length = 0;
   // Count all entries in the deoptimizing code list of every context.
   Object* context = isolate->heap()->native_contexts_list();
   while (!context->IsUndefined()) {
     Context* native_context = Context::cast(context);
     Object* element = native_context->DeoptimizedCodeListHead();
     while (!element->IsUndefined()) {
       Code* code = Code::cast(element);
       DCHECK(code->kind() == Code::OPTIMIZED_FUNCTION);
       length++;
       element = code->next_code_link();
     }
     context = Context::cast(context)->get(Context::NEXT_CONTEXT_LINK);
   }
   return length;
 }

References v8::internal::Context::cast(), DCHECK, v8::internal::Context::DeoptimizedCodeListHead(), v8::internal::FixedArray::get(), v8::internal::Isolate::heap(), isolate(), v8::internal::Code::kind(), v8::internal::Heap::native_contexts_list(), and v8::internal::Context::NEXT_CONTEXT_LINK.

Here is the call graph for this function:

◆ GetMaxDeoptTableSize()

size_t v8::internal::Deoptimizer::GetMaxDeoptTableSize ( )

static

Definition at line 101 of file deoptimizer.cc.

                                          {
   int entries_size =
       Deoptimizer::kMaxNumberOfEntries * Deoptimizer::table_entry_size_;
   int commit_page_size = static_cast<int>(base::OS::CommitPageSize());
   int page_count = ((kDeoptTableMaxEpilogueCodeSize + entries_size - 1) /
                     commit_page_size) + 1;
   return static_cast<size_t>(commit_page_size * page_count);
 }

References v8::base::OS::CommitPageSize(), v8::internal::kDeoptTableMaxEpilogueCodeSize, kMaxNumberOfEntries, and table_entry_size_.

Referenced by v8::internal::AllocateCodeChunk(), and EnsureCodeForDeoptimizationEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetOutputInfo()

int v8::internal::Deoptimizer::GetOutputInfo	(	DeoptimizationOutputData *	data,
		BailoutId	node_id,
		SharedFunctionInfo *	shared
	)

static

Definition at line 707 of file deoptimizer.cc.

                                                            {
   // TODO(kasperl): For now, we do a simple linear search for the PC
   // offset associated with the given node id. This should probably be
   // changed to a binary search.
   int length = data->DeoptPoints();
   for (int i = 0; i < length; i++) {
     if (data->AstId(i) == id) {
       return data->PcAndState(i)->value();
     }
   }
   OFStream os(stderr);
   os << "[couldn't find pc offset for node=" << id.ToInt() << "]\n"
      << "[method: " << shared->DebugName()->ToCString().get() << "]\n"
      << "[source:\n" << SourceCodeOf(shared) << "\n]" << endl;
  
   FATAL("unable to find pc offset during deoptimization");
   return -1;
 }

References v8::internal::DeoptimizationOutputData::AstId(), v8::internal::SharedFunctionInfo::DebugName(), v8::internal::DeoptimizationOutputData::DeoptPoints(), v8::internal::endl(), FATAL, v8::internal::DeoptimizationOutputData::PcAndState(), v8::internal::String::ToCString(), and v8::internal::Smi::value().

Referenced by DoComputeJSFrame(), v8::internal::OptimizedFrame::Summarize(), and v8::internal::SharedFunctionInfo::VerifyBailoutId().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Grab()

Deoptimizer * v8::internal::Deoptimizer::Grab ( Isolate * isolate )

static

Definition at line 111 of file deoptimizer.cc.

                                                {
   Deoptimizer* result = isolate->deoptimizer_data()->current_;
   CHECK_NE(result, NULL);
   result->DeleteFrameDescriptions();
   isolate->deoptimizer_data()->current_ = NULL;
   return result;
 }

References CHECK_NE, v8::internal::DeoptimizerData::current_, DeleteFrameDescriptions(), v8::internal::Isolate::deoptimizer_data(), isolate(), and NULL.

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_alignment_padding_offset()

static int v8::internal::Deoptimizer::has_alignment_padding_offset ( )

inlinestatic

Definition at line 241 of file deoptimizer.h.

                                             {
     return OFFSET_OF(Deoptimizer, has_alignment_padding_);
   }

References has_alignment_padding_, and OFFSET_OF.

◆ HasAlignmentPadding()

bool v8::internal::Deoptimizer::HasAlignmentPadding ( JSFunction * function )

private

Definition at line 122 of file deoptimizer-arm.cc.

                                                           {
   // There is no dynamic alignment padding on ARM in the input frame.
   return false;
 }

Referenced by DoComputeJSFrame().

Here is the caller graph for this function:

◆ input_offset()

static int v8::internal::Deoptimizer::input_offset ( )

inlinestatic

Definition at line 235 of file deoptimizer.h.

235 { return OFFSET_OF(Deoptimizer, input_); }

References input_, and OFFSET_OF.

Referenced by DoComputeJSFrame(), DoTranslateCommand(), and DoTranslateObject().

Here is the caller graph for this function:

◆ isolate()

Isolate* v8::internal::Deoptimizer::isolate ( ) const

inline

Definition at line 292 of file deoptimizer.h.

292 { return isolate_; }

References isolate_.

Referenced by AddObjectDoubleValue(), DebuggerInspectableFrame(), DeleteDebuggerInspectableFrame(), DeoptimizeAll(), v8::internal::DeoptimizedFrameInfo::DeoptimizedFrameInfo(), DeoptimizeMarkedCode(), DeoptimizeMarkedCodeForContext(), Deoptimizer(), DoComputeOutputFrames(), EnsureCodeForDeoptimizationEntry(), GetDeoptimizationEntry(), GetDeoptimizationId(), GetDeoptimizedCodeCount(), Grab(), New(), PatchCodeForDeoptimization(), and VisitAllOptimizedFunctions().

Here is the caller graph for this function:

◆ jsframe_count()

int v8::internal::Deoptimizer::jsframe_count ( ) const

inline

Definition at line 154 of file deoptimizer.h.

154 { return jsframe_count_; }

References jsframe_count_.

Referenced by DebuggerInspectableFrame(), and MaterializeHeapObjects().

Here is the caller graph for this function:

◆ MarkAllCodeForContext()

void v8::internal::Deoptimizer::MarkAllCodeForContext ( Context * native_context )

staticprivate

Definition at line 492 of file deoptimizer.cc.

                                                         {
   Object* element = context->OptimizedCodeListHead();
   while (!element->IsUndefined()) {
     Code* code = Code::cast(element);
     CHECK_EQ(code->kind(), Code::OPTIMIZED_FUNCTION);
     code->set_marked_for_deoptimization(true);
     element = code->next_code_link();
   }
 }

References CHECK_EQ, v8::internal::Code::kind(), v8::internal::Context::OptimizedCodeListHead(), and v8::internal::Code::set_marked_for_deoptimization().

Referenced by DeoptimizeAll(), and DeoptimizeGlobalObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MaterializeHeapNumbersForDebuggerInspectableFrame()

void v8::internal::Deoptimizer::MaterializeHeapNumbersForDebuggerInspectableFrame	(	Address	parameters_top,
		uint32_t	parameters_size,
		Address	expressions_top,
		uint32_t	expressions_size,
		DeoptimizedFrameInfo *	info
	)

Definition at line 2029 of file deoptimizer.cc.

                                 {
   CHECK_EQ(DEBUGGER, bailout_type_);
   Address parameters_bottom = parameters_top + parameters_size;
   Address expressions_bottom = expressions_top + expressions_size;
   for (int i = 0; i < deferred_heap_numbers_.length(); i++) {
     HeapNumberMaterializationDescriptor<Address> d = deferred_heap_numbers_[i];
  
     // Check of the heap number to materialize actually belong to the frame
     // being extracted.
     Address slot = d.destination();
     if (parameters_top <= slot && slot < parameters_bottom) {
       Handle<Object> num = isolate_->factory()->NewNumber(d.value());
  
       int index = (info->parameters_count() - 1) -
           static_cast<int>(slot - parameters_top) / kPointerSize;
  
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "Materializing a new heap number %p [%e] in slot %p"
                "for parameter slot #%d\n",
                reinterpret_cast<void*>(*num),
                d.value(),
                d.destination(),
                index);
       }
  
       info->SetParameter(index, *num);
     } else if (expressions_top <= slot && slot < expressions_bottom) {
       Handle<Object> num = isolate_->factory()->NewNumber(d.value());
  
       int index = info->expression_count() - 1 -
           static_cast<int>(slot - expressions_top) / kPointerSize;
  
       if (trace_scope_ != NULL) {
         PrintF(trace_scope_->file(),
                "Materializing a new heap number %p [%e] in slot %p"
                "for expression slot #%d\n",
                reinterpret_cast<void*>(*num),
                d.value(),
                d.destination(),
                index);
       }
  
       info->SetExpression(index, *num);
     }
   }
 }

References bailout_type_, CHECK_EQ, DEBUGGER, deferred_heap_numbers_, v8::internal::DeoptimizedFrameInfo::expression_count(), v8::internal::Isolate::factory(), isolate_, v8::internal::kPointerSize, NULL, v8::internal::DeoptimizedFrameInfo::parameters_count(), v8::internal::PrintF(), v8::internal::DeoptimizedFrameInfo::SetExpression(), v8::internal::DeoptimizedFrameInfo::SetParameter(), and trace_scope_.

Referenced by DebuggerInspectableFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MaterializeHeapObjects()

void v8::internal::Deoptimizer::MaterializeHeapObjects ( JavaScriptFrameIterator * it )

Definition at line 1922 of file deoptimizer.cc.

                                                                     {
   DCHECK_NE(DEBUGGER, bailout_type_);
  
   MaterializedObjectStore* materialized_store =
       isolate_->materialized_object_store();
   previously_materialized_objects_ = materialized_store->Get(stack_fp_);
   prev_materialized_count_ = previously_materialized_objects_.is_null() ?
       0 : previously_materialized_objects_->length();
  
   // Walk all JavaScript output frames with the given frame iterator.
   for (int frame_index = 0; frame_index < jsframe_count(); ++frame_index) {
     if (frame_index != 0) it->Advance();
     JavaScriptFrame* frame = it->frame();
     jsframe_functions_.Add(handle(frame->function(), isolate_));
     jsframe_has_adapted_arguments_.Add(frame->has_adapted_arguments());
   }
  
   // Handlify all tagged object values before triggering any allocation.
   List<Handle<Object> > values(deferred_objects_tagged_values_.length());
   for (int i = 0; i < deferred_objects_tagged_values_.length(); ++i) {
     values.Add(Handle<Object>(deferred_objects_tagged_values_[i], isolate_));
   }
  
   // Play it safe and clear all unhandlified values before we continue.
   deferred_objects_tagged_values_.Clear();
  
   // Materialize all heap numbers before looking at arguments because when the
   // output frames are used to materialize arguments objects later on they need
   // to already contain valid heap numbers.
   for (int i = 0; i < deferred_heap_numbers_.length(); i++) {
     HeapNumberMaterializationDescriptor<Address> d = deferred_heap_numbers_[i];
     Handle<Object> num = isolate_->factory()->NewNumber(d.value());
     if (trace_scope_ != NULL) {
       PrintF(trace_scope_->file(),
              "Materialized a new heap number %p [%e] in slot %p\n",
              reinterpret_cast<void*>(*num),
              d.value(),
              d.destination());
     }
     Memory::Object_at(d.destination()) = *num;
   }
  
   // Materialize all heap numbers required for arguments/captured objects.
   for (int i = 0; i < deferred_objects_double_values_.length(); i++) {
     HeapNumberMaterializationDescriptor<int> d =
         deferred_objects_double_values_[i];
     Handle<Object> num = isolate_->factory()->NewNumber(d.value());
     if (trace_scope_ != NULL) {
       PrintF(trace_scope_->file(),
              "Materialized a new heap number %p [%e] for object at %d\n",
              reinterpret_cast<void*>(*num),
              d.value(),
              d.destination());
     }
     DCHECK(values.at(d.destination())->IsTheHole());
     values.Set(d.destination(), num);
   }
  
   // Play it safe and clear all object double values before we continue.
   deferred_objects_double_values_.Clear();
  
   // Materialize arguments/captured objects.
   if (!deferred_objects_.is_empty()) {
     List<Handle<Object> > materialized_objects(deferred_objects_.length());
     materialized_objects_ = &materialized_objects;
     materialized_values_ = &values;
  
     while (materialization_object_index_ < deferred_objects_.length()) {
       int object_index = materialization_object_index_;
       ObjectMaterializationDescriptor descriptor =
           deferred_objects_.at(object_index);
  
       // Find a previously materialized object by de-duplication or
       // materialize a new instance of the object if necessary. Store
       // the materialized object into the frame slot.
       Handle<Object> object = MaterializeNextHeapObject();
       if (descriptor.slot_address() != NULL) {
         Memory::Object_at(descriptor.slot_address()) = *object;
       }
       if (trace_scope_ != NULL) {
         if (descriptor.is_arguments()) {
           PrintF(trace_scope_->file(),
                  "Materialized %sarguments object of length %d for %p: ",
                  ArgumentsObjectIsAdapted(object_index) ? "(adapted) " : "",
                  Handle<JSObject>::cast(object)->elements()->length(),
                  reinterpret_cast<void*>(descriptor.slot_address()));
         } else {
           PrintF(trace_scope_->file(),
                  "Materialized captured object of size %d for %p: ",
                  Handle<HeapObject>::cast(object)->Size(),
                  reinterpret_cast<void*>(descriptor.slot_address()));
         }
         object->ShortPrint(trace_scope_->file());
         PrintF(trace_scope_->file(), "\n");
       }
     }
  
     CHECK_EQ(materialization_object_index_, materialized_objects_->length());
     CHECK_EQ(materialization_value_index_, materialized_values_->length());
   }
  
   if (prev_materialized_count_ > 0) {
     materialized_store->Remove(stack_fp_);
   }
 }

References v8::internal::List< T, AllocationPolicy >::Add(), ArgumentsObjectIsAdapted(), v8::internal::List< T, AllocationPolicy >::at(), bailout_type_, CHECK_EQ, DCHECK, DCHECK_NE, DEBUGGER, deferred_heap_numbers_, deferred_objects_, deferred_objects_double_values_, deferred_objects_tagged_values_, v8::internal::Isolate::factory(), v8::internal::JavaScriptFrame::function(), v8::internal::MaterializedObjectStore::Get(), v8::internal::handle(), v8::internal::JavaScriptFrame::has_adapted_arguments(), isolate_, jsframe_count(), jsframe_functions_, jsframe_has_adapted_arguments_, materialization_object_index_, materialization_value_index_, v8::internal::Isolate::materialized_object_store(), materialized_objects_, materialized_values_, MaterializeNextHeapObject(), NULL, v8::internal::Memory::Object_at(), prev_materialized_count_, previously_materialized_objects_, v8::internal::PrintF(), v8::internal::MaterializedObjectStore::Remove(), v8::internal::List< T, AllocationPolicy >::Set(), stack_fp_, and trace_scope_.

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MaterializeNextHeapObject()

Handle< Object > v8::internal::Deoptimizer::MaterializeNextHeapObject ( )

private

Definition at line 1804 of file deoptimizer.cc.

                                                       {
   int object_index = materialization_object_index_++;
   ObjectMaterializationDescriptor desc = deferred_objects_[object_index];
   const int length = desc.object_length();
  
   if (desc.duplicate_object() >= 0) {
     // Found a previously materialized object by de-duplication.
     object_index = desc.duplicate_object();
     materialized_objects_->Add(Handle<Object>());
   } else if (desc.is_arguments() && ArgumentsObjectIsAdapted(object_index)) {
     // Use the arguments adapter frame we just built to materialize the
     // arguments object. FunctionGetArguments can't throw an exception.
     Handle<JSFunction> function = ArgumentsObjectFunction(object_index);
     Handle<JSObject> arguments = Handle<JSObject>::cast(
         Accessors::FunctionGetArguments(function));
     materialized_objects_->Add(arguments);
     // To keep consistent object counters, we still materialize the
     // nested values (but we throw them away).
     for (int i = 0; i < length; ++i) {
       MaterializeNextValue();
     }
   } else if (desc.is_arguments()) {
     // Construct an arguments object and copy the parameters to a newly
     // allocated arguments object backing store.
     Handle<JSFunction> function = ArgumentsObjectFunction(object_index);
     Handle<JSObject> arguments =
         isolate_->factory()->NewArgumentsObject(function, length);
     Handle<FixedArray> array = isolate_->factory()->NewFixedArray(length);
     DCHECK_EQ(array->length(), length);
     arguments->set_elements(*array);
     materialized_objects_->Add(arguments);
     for (int i = 0; i < length; ++i) {
       Handle<Object> value = MaterializeNextValue();
       array->set(i, *value);
     }
   } else {
     // Dispatch on the instance type of the object to be materialized.
     // We also need to make sure that the representation of all fields
     // in the given object are general enough to hold a tagged value.
     Handle<Map> map = Map::GeneralizeAllFieldRepresentations(
         Handle<Map>::cast(MaterializeNextValue()));
     switch (map->instance_type()) {
       case MUTABLE_HEAP_NUMBER_TYPE:
       case HEAP_NUMBER_TYPE: {
         // Reuse the HeapNumber value directly as it is already properly
         // tagged and skip materializing the HeapNumber explicitly. Turn mutable
         // heap numbers immutable.
         Handle<Object> object = MaterializeNextValue();
         if (object_index < prev_materialized_count_) {
           materialized_objects_->Add(Handle<Object>(
               previously_materialized_objects_->get(object_index), isolate_));
         } else {
           materialized_objects_->Add(object);
         }
         materialization_value_index_ += kDoubleSize / kPointerSize - 1;
         break;
       }
       case JS_OBJECT_TYPE: {
         Handle<JSObject> object =
             isolate_->factory()->NewJSObjectFromMap(map, NOT_TENURED, false);
         if (object_index < prev_materialized_count_) {
           materialized_objects_->Add(Handle<Object>(
               previously_materialized_objects_->get(object_index), isolate_));
         } else {
           materialized_objects_->Add(object);
         }
         Handle<Object> properties = MaterializeNextValue();
         Handle<Object> elements = MaterializeNextValue();
         object->set_properties(FixedArray::cast(*properties));
         object->set_elements(FixedArrayBase::cast(*elements));
         for (int i = 0; i < length - 3; ++i) {
           Handle<Object> value = MaterializeNextValue();
           FieldIndex index = FieldIndex::ForPropertyIndex(object->map(), i);
           object->FastPropertyAtPut(index, *value);
         }
         break;
       }
       case JS_ARRAY_TYPE: {
         Handle<JSArray> object =
             isolate_->factory()->NewJSArray(0, map->elements_kind());
         if (object_index < prev_materialized_count_) {
           materialized_objects_->Add(Handle<Object>(
               previously_materialized_objects_->get(object_index), isolate_));
         } else {
           materialized_objects_->Add(object);
         }
         Handle<Object> properties = MaterializeNextValue();
         Handle<Object> elements = MaterializeNextValue();
         Handle<Object> length = MaterializeNextValue();
         object->set_properties(FixedArray::cast(*properties));
         object->set_elements(FixedArrayBase::cast(*elements));
         object->set_length(*length);
         break;
       }
       default:
         PrintF(stderr,
                "[couldn't handle instance type %d]\n", map->instance_type());
         FATAL("Unsupported instance type");
     }
   }
  
   return materialized_objects_->at(object_index);
 }

References ArgumentsObjectFunction(), ArgumentsObjectIsAdapted(), v8::internal::Handle< T >::cast(), DCHECK_EQ, deferred_objects_, v8::internal::Isolate::factory(), FATAL, v8::internal::Accessors::FunctionGetArguments(), v8::internal::Map::GeneralizeAllFieldRepresentations(), v8::internal::HEAP_NUMBER_TYPE, isolate_, v8::internal::JS_ARRAY_TYPE, v8::internal::JS_OBJECT_TYPE, v8::internal::kDoubleSize, v8::internal::kPointerSize, map, materialization_object_index_, materialization_value_index_, materialized_objects_, MaterializeNextValue(), v8::internal::MUTABLE_HEAP_NUMBER_TYPE, v8::internal::NOT_TENURED, prev_materialized_count_, previously_materialized_objects_, and v8::internal::PrintF().

Referenced by MaterializeHeapObjects(), and MaterializeNextValue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MaterializeNextValue()

Handle< Object > v8::internal::Deoptimizer::MaterializeNextValue ( )

private

Definition at line 1909 of file deoptimizer.cc.

                                                  {
   int value_index = materialization_value_index_++;
   Handle<Object> value = materialized_values_->at(value_index);
   if (value->IsMutableHeapNumber()) {
     HeapNumber::cast(*value)->set_map(isolate_->heap()->heap_number_map());
   }
   if (*value == isolate_->heap()->arguments_marker()) {
     value = MaterializeNextHeapObject();
   }
   return value;
 }

References v8::internal::Isolate::heap(), isolate_, materialization_value_index_, materialized_values_, and MaterializeNextHeapObject().

Referenced by MaterializeNextHeapObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MessageFor()

const char * v8::internal::Deoptimizer::MessageFor ( BailoutType type )

static

Definition at line 536 of file deoptimizer.cc.

                                                     {
   switch (type) {
     case EAGER: return "eager";
     case SOFT: return "soft";
     case LAZY: return "lazy";
     case DEBUGGER: return "debugger";
   }
   FATAL("Unsupported deopt type");
   return NULL;
 }

References DEBUGGER, EAGER, FATAL, LAZY, NULL, and SOFT.

Referenced by DoComputeOutputFrames().

Here is the caller graph for this function:

◆ New()

Deoptimizer * v8::internal::Deoptimizer::New	(	JSFunction *	function,
		BailoutType	type,
		unsigned	bailout_id,
		Address	from,
		int	fp_to_sp_delta,
		Isolate *	isolate
	)

static

Definition at line 78 of file deoptimizer.cc.

                                                 {
   Deoptimizer* deoptimizer = new Deoptimizer(isolate,
                                              function,
                                              type,
                                              bailout_id,
                                              from,
                                              fp_to_sp_delta,
                                              NULL);
   CHECK(isolate->deoptimizer_data()->current_ == NULL);
   isolate->deoptimizer_data()->current_ = deoptimizer;
   return deoptimizer;
 }

References CHECK, v8::internal::DeoptimizerData::current_, Deoptimizer(), v8::internal::Isolate::deoptimizer_data(), isolate(), and NULL.

Here is the call graph for this function:

◆ output_count()

int v8::internal::Deoptimizer::output_count ( ) const

inline

Definition at line 147 of file deoptimizer.h.

147 { return output_count_; }

References output_count_.

◆ output_count_offset()

static int v8::internal::Deoptimizer::output_count_offset ( )

inlinestatic

Definition at line 236 of file deoptimizer.h.

                                    {
     return OFFSET_OF(Deoptimizer, output_count_);
   }

References OFFSET_OF, and output_count_.

◆ output_offset()

static int v8::internal::Deoptimizer::output_offset ( )

inlinestatic

Definition at line 239 of file deoptimizer.h.

239 { return OFFSET_OF(Deoptimizer, output_); }

References OFFSET_OF, and output_.

Referenced by DoComputeAccessorStubFrame(), DoComputeArgumentsAdaptorFrame(), DoComputeConstructStubFrame(), DoComputeJSFrame(), and DoTranslateCommand().

Here is the caller graph for this function:

◆ patch_size()

int v8::internal::Deoptimizer::patch_size ( )

static

Definition at line 18 of file deoptimizer-arm.cc.

                             {
   const int kCallInstructionSizeInWords = 3;
   return kCallInstructionSizeInWords * Assembler::kInstrSize;
 }

References v8::internal::Assembler::kInstrSize.

Referenced by v8::internal::LCodeGen::GenerateBodyInstructionPre(), and PatchCodeForDeoptimization().

Here is the caller graph for this function:

◆ PatchCodeForDeoptimization()

void v8::internal::Deoptimizer::PatchCodeForDeoptimization	(	Isolate *	isolate,
		Code *	code
	)

staticprivate

Definition at line 24 of file deoptimizer-arm.cc.

                                                                          {
   Address code_start_address = code->instruction_start();
   // Invalidate the relocation information, as it will become invalid by the
   // code patching below, and is not needed any more.
   code->InvalidateRelocation();
  
   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()->bkpt(0);
  
     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()->bkpt(0);
     }
   }
  
   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;
     Address call_address = code_start_address + deopt_data->Pc(i)->value();
     Address deopt_entry = GetDeoptimizationEntry(isolate, i, LAZY);
     // We need calls to have a predictable size in the unoptimized code, but
     // this is optimized code, so we don't have to have a predictable size.
     int call_size_in_bytes =
         MacroAssembler::CallSizeNotPredictableCodeSize(isolate,
                                                        deopt_entry,
                                                        RelocInfo::NONE32);
     int call_size_in_words = call_size_in_bytes / Assembler::kInstrSize;
     DCHECK(call_size_in_bytes % Assembler::kInstrSize == 0);
     DCHECK(call_size_in_bytes <= patch_size());
     CodePatcher patcher(call_address, call_size_in_words);
     patcher.masm()->Call(deopt_entry, RelocInfo::NONE32);
     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
   }
 }

References v8::internal::Assembler::bkpt(), v8::internal::MacroAssembler::Call(), v8::internal::MacroAssembler::CallSizeNotPredictableCodeSize(), DCHECK, v8::internal::DeoptimizationInputData::DeoptCount(), v8::internal::Code::FindCodeAgeSequence(), GetDeoptimizationEntry(), v8::internal::Code::instruction_end(), v8::internal::Code::instruction_start(), v8::internal::Code::InvalidateRelocation(), isolate(), v8::internal::Assembler::kInstrSize, v8::internal::kNoCodeAgeSequenceLength, LAZY, v8::internal::CodePatcher::masm(), v8::internal::RelocInfo::NONE32, NULL, and patch_size().

Referenced by DeoptimizeMarkedCodeForContext().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintFunctionName()

void v8::internal::Deoptimizer::PrintFunctionName ( )

private

Definition at line 638 of file deoptimizer.cc.

                                     {
   if (function_->IsJSFunction()) {
     function_->PrintName(trace_scope_->file());
   } else {
     PrintF(trace_scope_->file(),
            "%s", Code::Kind2String(compiled_code_->kind()));
   }
 }

References compiled_code_, function_, v8::internal::Code::kind(), v8::internal::Code::Kind2String(), v8::internal::PrintF(), v8::internal::JSFunction::PrintName(), and trace_scope_.

Referenced by DoComputeOutputFrames().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetPlatformCompiledStubRegisters()

void v8::internal::Deoptimizer::SetPlatformCompiledStubRegisters	(	FrameDescription *	output_frame,
		CodeStubDescriptor *	desc
	)

private

Definition at line 103 of file deoptimizer-arm.cc.

                                                                     {
   ApiFunction function(descriptor->deoptimization_handler());
   ExternalReference xref(&function, ExternalReference::BUILTIN_CALL, isolate_);
   intptr_t handler = reinterpret_cast<intptr_t>(xref.address());
   int params = descriptor->GetHandlerParameterCount();
   output_frame->SetRegister(r0.code(), params);
   output_frame->SetRegister(r1.code(), handler);
 }

References v8::internal::Register::code(), v8::internal::CodeStubDescriptor::deoptimization_handler(), v8::internal::CodeStubDescriptor::GetHandlerParameterCount(), isolate_, v8::internal::r0, v8::internal::r1, and v8::internal::FrameDescription::SetRegister().

Referenced by DoComputeCompiledStubFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TraceEnabledFor()

bool v8::internal::Deoptimizer::TraceEnabledFor	(	BailoutType	deopt_type,
		StackFrame::Type	frame_type
	)

static

Definition at line 520 of file deoptimizer.cc.

                                                              {
   switch (deopt_type) {
     case EAGER:
     case SOFT:
     case LAZY:
     case DEBUGGER:
       return (frame_type == StackFrame::STUB)
           ? FLAG_trace_stub_failures
           : FLAG_trace_deopt;
   }
   FATAL("Unsupported deopt type");
   return false;
 }

References DEBUGGER, EAGER, FATAL, LAZY, SOFT, and v8::internal::STUB.

Referenced by Deoptimizer().

Here is the caller graph for this function:

◆ VisitAllOptimizedFunctions()

void v8::internal::Deoptimizer::VisitAllOptimizedFunctions	(	Isolate *	isolate,
		OptimizedFunctionVisitor *	visitor
	)

static

Definition at line 284 of file deoptimizer.cc.

                                        {
   DisallowHeapAllocation no_allocation;
  
   // Run through the list of all native contexts.
   Object* context = isolate->heap()->native_contexts_list();
   while (!context->IsUndefined()) {
     VisitAllOptimizedFunctionsForContext(Context::cast(context), visitor);
     context = Context::cast(context)->get(Context::NEXT_CONTEXT_LINK);
   }
 }

References v8::internal::Context::cast(), v8::internal::FixedArray::get(), v8::internal::Isolate::heap(), isolate(), v8::internal::Heap::native_contexts_list(), v8::internal::Context::NEXT_CONTEXT_LINK, and VisitAllOptimizedFunctionsForContext().

Referenced by v8::internal::DeoptimizeDependentFunctions(), and v8::internal::EnumerateCompiledFunctions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ VisitAllOptimizedFunctionsForContext()

void v8::internal::Deoptimizer::VisitAllOptimizedFunctionsForContext	(	Context *	context,
		OptimizedFunctionVisitor *	visitor
	)

staticprivate

Definition at line 240 of file deoptimizer.cc.

                                                          {
   DisallowHeapAllocation no_allocation;
  
   CHECK(context->IsNativeContext());
  
   visitor->EnterContext(context);
  
   // Visit the list of optimized functions, removing elements that
   // no longer refer to optimized code.
   JSFunction* prev = NULL;
   Object* element = context->OptimizedFunctionsListHead();
   while (!element->IsUndefined()) {
     JSFunction* function = JSFunction::cast(element);
     Object* next = function->next_function_link();
     if (function->code()->kind() != Code::OPTIMIZED_FUNCTION ||
         (visitor->VisitFunction(function),
          function->code()->kind() != Code::OPTIMIZED_FUNCTION)) {
       // The function no longer refers to optimized code, or the visitor
       // changed the code to which it refers to no longer be optimized code.
       // Remove the function from this list.
       if (prev != NULL) {
         prev->set_next_function_link(next);
       } else {
         context->SetOptimizedFunctionsListHead(next);
       }
       // The visitor should not alter the link directly.
       CHECK_EQ(function->next_function_link(), next);
       // Set the next function link to undefined to indicate it is no longer
       // in the optimized functions list.
       function->set_next_function_link(context->GetHeap()->undefined_value());
     } else {
       // The visitor should not alter the link directly.
       CHECK_EQ(function->next_function_link(), next);
       // preserve this element.
       prev = function;
     }
     element = next;
   }
  
   visitor->LeaveContext(context);
 }

References CHECK, CHECK_EQ, function(), v8::internal::HeapObject::GetHeap(), v8::internal::Context::IsNativeContext(), NULL, v8::internal::Context::OptimizedFunctionsListHead(), and v8::internal::Context::SetOptimizedFunctionsListHead().

Referenced by DeoptimizeMarkedCodeForContext(), and VisitAllOptimizedFunctions().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

◆ DeoptimizedFrameInfo

friend class DeoptimizedFrameInfo

friend

Definition at line 454 of file deoptimizer.h.

Referenced by DebuggerInspectableFrame().

◆ FrameDescription

friend class FrameDescription

friend

Definition at line 453 of file deoptimizer.h.

Referenced by Deoptimizer(), DoComputeAccessorStubFrame(), DoComputeArgumentsAdaptorFrame(), DoComputeCompiledStubFrame(), DoComputeConstructStubFrame(), and DoComputeJSFrame().

Member Data Documentation

◆ bailout_id_

unsigned v8::internal::Deoptimizer::bailout_id_

private

Definition at line 408 of file deoptimizer.h.

Referenced by ComputeOutgoingArgumentSize(), and DoComputeOutputFrames().

◆ bailout_type_

BailoutType v8::internal::Deoptimizer::bailout_type_

private

Definition at line 409 of file deoptimizer.h.

Referenced by bailout_type(), Deoptimizer(), DoComputeJSFrame(), DoComputeOutputFrames(), FindOptimizedCode(), MaterializeHeapNumbersForDebuggerInspectableFrame(), and MaterializeHeapObjects().

◆ compiled_code_

Code* v8::internal::Deoptimizer::compiled_code_

private

Definition at line 407 of file deoptimizer.h.

Referenced by compiled_code(), ComputeInputFrameSize(), ComputeLiteral(), ComputeOutgoingArgumentSize(), Deoptimizer(), DoComputeCompiledStubFrame(), DoComputeJSFrame(), DoComputeOutputFrames(), and PrintFunctionName().

◆ deferred_heap_numbers_

List<HeapNumberMaterializationDescriptor<Address> > v8::internal::Deoptimizer::deferred_heap_numbers_

private

Definition at line 428 of file deoptimizer.h.

Referenced by AddDoubleValue(), MaterializeHeapNumbersForDebuggerInspectableFrame(), and MaterializeHeapObjects().

◆ deferred_objects_

List<ObjectMaterializationDescriptor> v8::internal::Deoptimizer::deferred_objects_

private

Definition at line 427 of file deoptimizer.h.

Referenced by AddObjectDuplication(), AddObjectStart(), ArgumentsObjectFunction(), ArgumentsObjectIsAdapted(), DoComputeConstructStubFrame(), DoTranslateCommand(), DoTranslateObject(), DoTranslateObjectAndSkip(), MaterializeHeapObjects(), and MaterializeNextHeapObject().

◆ deferred_objects_double_values_

List<HeapNumberMaterializationDescriptor<int> > v8::internal::Deoptimizer::deferred_objects_double_values_

private

Definition at line 426 of file deoptimizer.h.

Referenced by AddObjectDoubleValue(), and MaterializeHeapObjects().

◆ deferred_objects_tagged_values_

List<Object*> v8::internal::Deoptimizer::deferred_objects_tagged_values_

private

Definition at line 424 of file deoptimizer.h.

Referenced by AddObjectDoubleValue(), AddObjectTaggedValue(), and MaterializeHeapObjects().

◆ fp_to_sp_delta_

int v8::internal::Deoptimizer::fp_to_sp_delta_

private

Definition at line 411 of file deoptimizer.h.

Referenced by ComputeInputFrameSize(), and DoComputeOutputFrames().

◆ from_

Address v8::internal::Deoptimizer::from_

private

Definition at line 410 of file deoptimizer.h.

Referenced by FindOptimizedCode().

◆ function_

JSFunction* v8::internal::Deoptimizer::function_

private

Definition at line 406 of file deoptimizer.h.

Referenced by ComputeInputFrameSize(), DoComputeJSFrame(), DoComputeOutputFrames(), FindDeoptimizingCode(), function(), and PrintFunctionName().

◆ has_alignment_padding_

int v8::internal::Deoptimizer::has_alignment_padding_

private

Definition at line 412 of file deoptimizer.h.

Referenced by DoComputeJSFrame(), DoComputeOutputFrames(), and has_alignment_padding_offset().

◆ input_

FrameDescription* v8::internal::Deoptimizer::input_

private

Definition at line 415 of file deoptimizer.h.

Referenced by CopyDoubleRegisters(), DeleteFrameDescriptions(), Deoptimizer(), DoComputeCompiledStubFrame(), DoComputeJSFrame(), DoComputeOutputFrames(), DoTranslateCommand(), DoTranslateObject(), FillInputFrame(), input_offset(), and ~Deoptimizer().

◆ isolate_

Isolate* v8::internal::Deoptimizer::isolate_

private

Definition at line 405 of file deoptimizer.h.

Referenced by DoComputeAccessorStubFrame(), DoComputeArgumentsAdaptorFrame(), DoComputeCompiledStubFrame(), DoComputeConstructStubFrame(), DoComputeJSFrame(), DoTranslateCommand(), DoTranslateObject(), FindOptimizedCode(), isolate(), MaterializeHeapNumbersForDebuggerInspectableFrame(), MaterializeHeapObjects(), MaterializeNextHeapObject(), MaterializeNextValue(), and SetPlatformCompiledStubRegisters().

◆ jsframe_count_

int v8::internal::Deoptimizer::jsframe_count_

private

Definition at line 419 of file deoptimizer.h.

Referenced by AddObjectDuplication(), AddObjectStart(), ArgumentsObjectFunction(), ArgumentsObjectIsAdapted(), DoComputeOutputFrames(), and jsframe_count().

◆ jsframe_functions_

List<Handle<JSFunction> > v8::internal::Deoptimizer::jsframe_functions_

private

Definition at line 436 of file deoptimizer.h.

Referenced by ArgumentsObjectFunction(), and MaterializeHeapObjects().

◆ jsframe_has_adapted_arguments_

List<bool> v8::internal::Deoptimizer::jsframe_has_adapted_arguments_

private

Definition at line 437 of file deoptimizer.h.

Referenced by ArgumentsObjectIsAdapted(), and MaterializeHeapObjects().

◆ kBailoutTypesWithCodeEntry

const int v8::internal::Deoptimizer::kBailoutTypesWithCodeEntry = SOFT + 1

static

Definition at line 102 of file deoptimizer.h.

Referenced by v8::internal::DeoptimizerData::DeoptimizerData(), GetDeoptimizationEntry(), and v8::internal::DeoptimizerData::~DeoptimizerData().

◆ kMaxNumberOfEntries

const int v8::internal::Deoptimizer::kMaxNumberOfEntries = 16384

staticprivate

Definition at line 296 of file deoptimizer.h.

Referenced by EnsureCodeForDeoptimizationEntry(), GetDeoptimizationEntry(), GetDeoptimizationId(), and GetMaxDeoptTableSize().

◆ kMinNumberOfEntries

const int v8::internal::Deoptimizer::kMinNumberOfEntries = 64

staticprivate

Definition at line 295 of file deoptimizer.h.

Referenced by EnsureCodeForDeoptimizationEntry().

◆ kNotDeoptimizationEntry

const int v8::internal::Deoptimizer::kNotDeoptimizationEntry = -1

static

Definition at line 247 of file deoptimizer.h.

Referenced by GetDeoptimizationId().

◆ materialization_object_index_

int v8::internal::Deoptimizer::materialization_object_index_

private

Definition at line 443 of file deoptimizer.h.

Referenced by MaterializeHeapObjects(), and MaterializeNextHeapObject().

◆ materialization_value_index_

int v8::internal::Deoptimizer::materialization_value_index_

private

Definition at line 442 of file deoptimizer.h.

Referenced by MaterializeHeapObjects(), MaterializeNextHeapObject(), and MaterializeNextValue().

◆ materialized_objects_

List<Handle<Object> >* v8::internal::Deoptimizer::materialized_objects_

private

Definition at line 441 of file deoptimizer.h.

Referenced by MaterializeHeapObjects(), and MaterializeNextHeapObject().

◆ materialized_values_

List<Handle<Object> >* v8::internal::Deoptimizer::materialized_values_

private

Definition at line 440 of file deoptimizer.h.

Referenced by MaterializeHeapObjects(), and MaterializeNextValue().

◆ output_

FrameDescription** v8::internal::Deoptimizer::output_

private

Definition at line 421 of file deoptimizer.h.

Referenced by ConvertJSFrameIndexToFrameIndex(), DebuggerInspectableFrame(), DeleteFrameDescriptions(), v8::internal::DeoptimizedFrameInfo::DeoptimizedFrameInfo(), DoComputeAccessorStubFrame(), DoComputeArgumentsAdaptorFrame(), DoComputeCompiledStubFrame(), DoComputeConstructStubFrame(), DoComputeJSFrame(), DoComputeOutputFrames(), DoTranslateCommand(), output_offset(), and ~Deoptimizer().

◆ output_count_

int v8::internal::Deoptimizer::output_count_

private

Definition at line 417 of file deoptimizer.h.

Referenced by DeleteFrameDescriptions(), DoComputeAccessorStubFrame(), DoComputeArgumentsAdaptorFrame(), DoComputeConstructStubFrame(), DoComputeJSFrame(), DoComputeOutputFrames(), output_count(), and output_count_offset().

◆ prev_materialized_count_

int v8::internal::Deoptimizer::prev_materialized_count_

private

Definition at line 433 of file deoptimizer.h.

Referenced by MaterializeHeapObjects(), and MaterializeNextHeapObject().

◆ previously_materialized_objects_

Handle<FixedArray> v8::internal::Deoptimizer::previously_materialized_objects_

private

Definition at line 432 of file deoptimizer.h.

Referenced by MaterializeHeapObjects(), and MaterializeNextHeapObject().

◆ stack_fp_

Address v8::internal::Deoptimizer::stack_fp_

private

Definition at line 431 of file deoptimizer.h.

Referenced by DoComputeOutputFrames(), and MaterializeHeapObjects().

◆ table_entry_size_

const int v8::internal::Deoptimizer::table_entry_size_ = 8

staticprivate

Definition at line 451 of file deoptimizer.h.

Referenced by v8::internal::Deoptimizer::TableEntryGenerator::GeneratePrologue(), GetDeoptimizationEntry(), GetDeoptimizationId(), and GetMaxDeoptTableSize().

◆ trace_scope_

CodeTracer::Scope* v8::internal::Deoptimizer::trace_scope_

private

Definition at line 449 of file deoptimizer.h.

Referenced by Deoptimizer(), DoComputeAccessorStubFrame(), DoComputeArgumentsAdaptorFrame(), DoComputeCompiledStubFrame(), DoComputeConstructStubFrame(), DoComputeJSFrame(), DoComputeOutputFrames(), DoTranslateCommand(), DoTranslateObject(), DoTranslateObjectAndSkip(), MaterializeHeapNumbersForDebuggerInspectableFrame(), MaterializeHeapObjects(), PrintFunctionName(), and ~Deoptimizer().

The documentation for this class was generated from the following files:

/mnt/V8SourceCode/src/deoptimizer.h
/mnt/V8SourceCode/src/arm/deoptimizer-arm.cc
/mnt/V8SourceCode/src/arm64/deoptimizer-arm64.cc
/mnt/V8SourceCode/src/deoptimizer.cc
/mnt/V8SourceCode/src/mips/deoptimizer-mips.cc
/mnt/V8SourceCode/src/mips64/deoptimizer-mips64.cc

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ BailoutType

◆ GetEntryMode

Constructor & Destructor Documentation

◆ ~Deoptimizer()

◆ Deoptimizer()

Member Function Documentation

◆ AddDoubleValue()

◆ AddObjectDoubleValue()

◆ AddObjectDuplication()

◆ AddObjectStart()

◆ AddObjectTaggedValue()

◆ ArgumentsObjectFunction()

◆ ArgumentsObjectIsAdapted()

◆ bailout_type()

◆ compiled_code()

◆ ComputeFixedSize()

◆ ComputeIncomingArgumentSize()

◆ ComputeInputFrameSize()

◆ ComputeLiteral()

◆ ComputeOutgoingArgumentSize()

◆ ComputeOutputFrames()

◆ ConvertJSFrameIndexToFrameIndex()

◆ CopyDoubleRegisters()

◆ DebuggerInspectableFrame()

◆ DeleteDebuggerInspectableFrame()

◆ DeleteFrameDescriptions()

◆ DeoptimizeAll()

◆ DeoptimizeFunction()

◆ DeoptimizeGlobalObject()

◆ DeoptimizeMarkedCode()

◆ DeoptimizeMarkedCodeForContext()

◆ DoComputeAccessorStubFrame()

◆ DoComputeArgumentsAdaptorFrame()

◆ DoComputeCompiledStubFrame()

◆ DoComputeConstructStubFrame()

◆ DoComputeJSFrame()

◆ DoComputeOutputFrames()

◆ DoTranslateCommand()

◆ DoTranslateObject()

◆ DoTranslateObjectAndSkip()

◆ EnsureCodeForDeoptimizationEntry()

◆ EnsureRelocSpaceForLazyDeoptimization()

◆ FillInputFrame()

◆ FindDeoptimizingCode()

◆ FindOptimizedCode()

◆ function()

◆ GenerateDeoptimizationEntries()

◆ GetDeoptimizationEntry()

◆ GetDeoptimizationId()

◆ GetDeoptimizedCodeCount()

◆ GetMaxDeoptTableSize()

◆ GetOutputInfo()

◆ Grab()

◆ has_alignment_padding_offset()

◆ HasAlignmentPadding()

◆ input_offset()

◆ isolate()

◆ jsframe_count()

◆ MarkAllCodeForContext()

◆ MaterializeHeapNumbersForDebuggerInspectableFrame()

◆ MaterializeHeapObjects()

◆ MaterializeNextHeapObject()

◆ MaterializeNextValue()

◆ MessageFor()

◆ New()

◆ output_count()

◆ output_count_offset()

◆ output_offset()