v8::internal::LChunk Class Reference

#include <lithium.h>

Inheritance diagram for v8::internal::LChunk:

Collaboration diagram for v8::internal::LChunk:

Public Member Functions
void	AddInstruction (LInstruction *instruction, HBasicBlock *block)
LConstantOperand *	DefineConstantOperand (HConstant *constant)
HConstant *	LookupConstant (LConstantOperand *operand) const
Representation	LookupLiteralRepresentation (LConstantOperand *operand) const
int	ParameterAt (int index)
int	GetParameterStackSlot (int index) const
int	spill_slot_count () const
CompilationInfo *	info () const
HGraph *	graph () const
Isolate *	isolate () const
const ZoneList< LInstruction * > *	instructions () const
void	AddGapMove (int index, LOperand *from, LOperand *to)
LGap *	GetGapAt (int index) const
bool	IsGapAt (int index) const
int	NearestGapPos (int index) const
void	MarkEmptyBlocks ()
const ZoneList< LPointerMap * > *	pointer_maps () const
LLabel *	GetLabel (int block_id) const
int	LookupDestination (int block_id) const
Label *	GetAssemblyLabel (int block_id) const
const ZoneList< Handle< JSFunction > > *	inlined_closures () const
void	AddInlinedClosure (Handle< JSFunction > closure)
void	AddDeprecationDependency (Handle< Map > map)
void	AddStabilityDependency (Handle< Map > map)
Zone *	zone () const
Handle< Code >	Codegen ()
void	set_allocated_double_registers (BitVector *allocated_registers)
BitVector *	allocated_double_registers ()
Public Member Functions inherited from v8::internal::ZoneObject
	INLINE (void *operator new(size_t size, Zone *zone))
void	operator delete (void *, size_t)
void	operator delete (void *pointer, Zone *zone)

Static Public Member Functions
static LChunk *	NewChunk (HGraph *graph)

Protected Member Functions
	LChunk (CompilationInfo *info, HGraph *graph)

Protected Attributes
int	spill_slot_count_

Private Types
typedef std::less< Handle< Map > >	MapLess
typedef zone_allocator< Handle< Map > >	MapAllocator
typedef std::set< Handle< Map >, MapLess, MapAllocator >	MapSet

Private Member Functions
void	CommitDependencies (Handle< Code > code) const

Private Attributes
CompilationInfo *	info_
HGraph *const	graph_
BitVector *	allocated_double_registers_
ZoneList< LInstruction * >	instructions_
ZoneList< LPointerMap * >	pointer_maps_
ZoneList< Handle< JSFunction > >	inlined_closures_
MapSet	deprecation_dependencies_
MapSet	stability_dependencies_

Detailed Description

Definition at line 619 of file lithium.h.

Member Typedef Documentation

MapAllocator

typedef zone_allocator<Handle<Map> > v8::internal::LChunk::MapAllocator

private

Definition at line 683 of file lithium.h.

MapLess

typedef std::less<Handle<Map> > v8::internal::LChunk::MapLess

private

Definition at line 682 of file lithium.h.

MapSet

typedef std::set<Handle<Map>, MapLess, MapAllocator> v8::internal::LChunk::MapSet

private

Definition at line 684 of file lithium.h.

Constructor & Destructor Documentation

LChunk()

v8::internal::LChunk::LChunk ( CompilationInfo *  info, HGraph *  graph  )

protected

Definition at line 267 of file lithium.cc.

    : spill_slot_count_(0),
      info_(info),
      graph_(graph),
      instructions_(32, info->zone()),
      pointer_maps_(8, info->zone()),
      inlined_closures_(1, info->zone()),
      deprecation_dependencies_(MapLess(), MapAllocator(info->zone())),
      stability_dependencies_(MapLess(), MapAllocator(info->zone())) {}

Member Function Documentation

AddDeprecationDependency()

void v8::internal::LChunk::AddDeprecationDependency ( Handle< Map >  map )

inline

Definition at line 653 of file lithium.h.

                                                 {
    DCHECK(!map->is_deprecated());
    if (!map->CanBeDeprecated()) return;
    DCHECK(!info_->IsStub());
    deprecation_dependencies_.insert(map);
  }

References DCHECK, deprecation_dependencies_, info_, v8::internal::CompilationInfo::IsStub(), and map.

Here is the call graph for this function:

AddGapMove()

void v8::internal::LChunk::AddGapMove	(	int	index,
		LOperand *	from,
		LOperand *	to
	)

Definition at line 396 of file lithium.cc.

                                                               {
  GetGapAt(index)->GetOrCreateParallelMove(
      LGap::START, zone())->AddMove(from, to, zone());
}

References GetGapAt(), v8::internal::LGap::GetOrCreateParallelMove(), v8::internal::LGap::START, to(), and zone().

Here is the call graph for this function:

AddInlinedClosure()

void v8::internal::LChunk::AddInlinedClosure ( Handle< JSFunction >  closure )

inline

Definition at line 649 of file lithium.h.

                                                     {
    inlined_closures_.Add(closure, zone());
  }

References inlined_closures_, and zone().

Here is the call graph for this function:

AddInstruction()

void v8::internal::LChunk::AddInstruction	(	LInstruction *	instruction,
		HBasicBlock *	block
	)

Definition at line 335 of file lithium.cc.

                                                                   {
  LInstructionGap* gap = new (zone()) LInstructionGap(block);
  gap->set_hydrogen_value(instr->hydrogen_value());
  int index = -1;
  if (instr->IsControl()) {
    instructions_.Add(gap, zone());
    index = instructions_.length();
    instructions_.Add(instr, zone());
  } else {
    index = instructions_.length();
    instructions_.Add(instr, zone());
    instructions_.Add(gap, zone());
  }
  if (instr->HasPointerMap()) {
    pointer_maps_.Add(instr->pointer_map(), zone());
    instr->pointer_map()->set_lithium_position(index);
  }
}

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::LInstruction::HasPointerMap(), v8::internal::LInstruction::hydrogen_value(), instructions_, v8::internal::LInstruction::IsControl(), v8::internal::LInstruction::pointer_map(), pointer_maps_, and zone().

Here is the call graph for this function:

AddStabilityDependency()

void v8::internal::LChunk::AddStabilityDependency ( Handle< Map >  map )

inline

Definition at line 660 of file lithium.h.

                                               {
    DCHECK(map->is_stable());
    if (!map->CanTransition()) return;
    DCHECK(!info_->IsStub());
    stability_dependencies_.insert(map);
  }

References DCHECK, info_, v8::internal::CompilationInfo::IsStub(), map, and stability_dependencies_.

Here is the call graph for this function:

allocated_double_registers()

BitVector* v8::internal::LChunk::allocated_double_registers ( )

inline

Definition at line 672 of file lithium.h.

                                          {
    return allocated_double_registers_;
  }

References allocated_double_registers_.

Referenced by set_allocated_double_registers().

Here is the caller graph for this function:

Codegen()

Handle< Code > v8::internal::LChunk::Codegen

(

)

Definition at line 461 of file lithium.cc.

                             {
  MacroAssembler assembler(info()->isolate(), NULL, 0);
  LOG_CODE_EVENT(info()->isolate(),
                 CodeStartLinePosInfoRecordEvent(
                     assembler.positions_recorder()));
  // TODO(yangguo) remove this once the code serializer handles code stubs.
  if (info()->will_serialize()) assembler.enable_serializer();
  LCodeGen generator(this, &assembler, info());
 
  MarkEmptyBlocks();
 
  if (generator.GenerateCode()) {
    generator.CheckEnvironmentUsage();
    CodeGenerator::MakeCodePrologue(info(), "optimized");
    Code::Flags flags = info()->flags();
    Handle<Code> code =
        CodeGenerator::MakeCodeEpilogue(&assembler, flags, info());
    generator.FinishCode(code);
    CommitDependencies(code);
    code->set_is_crankshafted(true);
    void* jit_handler_data =
        assembler.positions_recorder()->DetachJITHandlerData();
    LOG_CODE_EVENT(info()->isolate(),
                   CodeEndLinePosInfoRecordEvent(*code, jit_handler_data));
 
    CodeGenerator::PrintCode(code, info());
    DCHECK(!(info()->isolate()->serializer_enabled() &&
             info()->GetMustNotHaveEagerFrame() &&
             generator.NeedsEagerFrame()));
    return code;
  }
  assembler.AbortedCodeGeneration();
  return Handle<Code>::null();
}

References v8::internal::Assembler::AbortedCodeGeneration(), CommitDependencies(), DCHECK, v8::internal::AssemblerBase::enable_serializer(), v8::internal::LCodeGen::FinishCode(), v8::internal::CompilationInfo::flags(), v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::LCodeGen::GenerateCode(), info(), isolate(), LOG_CODE_EVENT, v8::internal::CodeGenerator::MakeCodeEpilogue(), v8::internal::CodeGenerator::MakeCodePrologue(), MarkEmptyBlocks(), v8::internal::LCodeGen::NeedsEagerFrame(), NULL, v8::internal::Handle< T >::null(), v8::internal::Assembler::positions_recorder(), and v8::internal::CodeGenerator::PrintCode().

Referenced by v8::internal::DoGenerateCode(), and v8::internal::OptimizedCompileJob::GenerateCode().

Here is the call graph for this function:

Here is the caller graph for this function:

CommitDependencies()

void v8::internal::LChunk::CommitDependencies ( Handle< Code >  code ) const

private

Definition at line 413 of file lithium.cc.

                                                       {
  for (MapSet::const_iterator it = deprecation_dependencies_.begin(),
       iend = deprecation_dependencies_.end(); it != iend; ++it) {
    Handle<Map> map = *it;
    DCHECK(!map->is_deprecated());
    DCHECK(map->CanBeDeprecated());
    Map::AddDependentCode(map, DependentCode::kTransitionGroup, code);
  }
 
  for (MapSet::const_iterator it = stability_dependencies_.begin(),
       iend = stability_dependencies_.end(); it != iend; ++it) {
    Handle<Map> map = *it;
    DCHECK(map->is_stable());
    DCHECK(map->CanTransition());
    Map::AddDependentCode(map, DependentCode::kPrototypeCheckGroup, code);
  }
 
  info_->CommitDependencies(code);
}

References v8::internal::Map::AddDependentCode(), v8::internal::CompilationInfo::CommitDependencies(), DCHECK, deprecation_dependencies_, info_, v8::internal::DependentCode::kPrototypeCheckGroup, v8::internal::DependentCode::kTransitionGroup, map, and stability_dependencies_.

Referenced by Codegen().

Here is the call graph for this function:

Here is the caller graph for this function:

DefineConstantOperand()

LConstantOperand * v8::internal::LChunk::DefineConstantOperand

(

HConstant *

constant

)

Definition at line 355 of file lithium.cc.

                                                                   {
  return LConstantOperand::Create(constant->id(), zone());
}

References zone().

Here is the call graph for this function:

GetAssemblyLabel()

Label * v8::internal::LChunk::GetAssemblyLabel

(

int

block_id

)

const

Definition at line 293 of file lithium.cc.

                                                  {
  LLabel* label = GetLabel(block_id);
  DCHECK(!label->HasReplacement());
  return label->label();
}

References DCHECK, and GetLabel().

Referenced by v8::internal::LControlInstruction< I, T >::FalseLabel(), and v8::internal::LControlInstruction< I, T >::TrueLabel().

Here is the call graph for this function:

Here is the caller graph for this function:

GetGapAt()

LGap * v8::internal::LChunk::GetGapAt

(

int

index

)

const

Definition at line 380 of file lithium.cc.

                                      {
  return LGap::cast(instructions_[index]);
}

References v8::internal::LGap::cast(), and instructions_.

Referenced by AddGapMove().

Here is the call graph for this function:

Here is the caller graph for this function:

GetLabel()

LLabel * v8::internal::LChunk::GetLabel

(

int

block_id

)

const

Definition at line 278 of file lithium.cc.

                                           {
  HBasicBlock* block = graph_->blocks()->at(block_id);
  int first_instruction = block->first_instruction_index();
  return LLabel::cast(instructions_[first_instruction]);
}

References graph_, and instructions_.

Referenced by GetAssemblyLabel(), LookupDestination(), and MarkEmptyBlocks().

Here is the caller graph for this function:

GetParameterStackSlot()

int v8::internal::LChunk::GetParameterStackSlot

(

int

index

)

const

Definition at line 360 of file lithium.cc.

                                                 {
  // The receiver is at index 0, the first parameter at index 1, so we
  // shift all parameter indexes down by the number of parameters, and
  // make sure they end up negative so they are distinguishable from
  // spill slots.
  int result = index - info()->num_parameters() - 1;
 
  DCHECK(result < 0);
  return result;
}

References DCHECK, info(), and v8::internal::CompilationInfo::num_parameters().

Here is the call graph for this function:

graph()

HGraph* v8::internal::LChunk::graph ( ) const

inline

Definition at line 632 of file lithium.h.

{ return graph_; }

References graph_.

Referenced by MarkEmptyBlocks(), and NewChunk().

Here is the caller graph for this function:

info()

CompilationInfo* v8::internal::LChunk::info ( ) const

inline

Definition at line 631 of file lithium.h.

{ return info_; }

References info_.

Referenced by Codegen(), v8::internal::DoGenerateCode(), GetParameterStackSlot(), NewChunk(), ParameterAt(), and set_allocated_double_registers().

Here is the caller graph for this function:

inlined_closures()

const ZoneList<Handle<JSFunction> >* v8::internal::LChunk::inlined_closures ( ) const

inline

Definition at line 645 of file lithium.h.

                                                                {
    return &inlined_closures_;
  }

References inlined_closures_.

instructions()

const ZoneList<LInstruction*>* v8::internal::LChunk::instructions ( ) const

inline

Definition at line 634 of file lithium.h.

{ return &instructions_; }

References instructions_.

Referenced by MarkEmptyBlocks().

Here is the caller graph for this function:

IsGapAt()

bool v8::internal::LChunk::IsGapAt

(

int

index

)

const

Definition at line 385 of file lithium.cc.

                                    {
  return instructions_[index]->IsGap();
}

References instructions_.

Referenced by NearestGapPos().

Here is the caller graph for this function:

isolate()

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

inline

Definition at line 633 of file lithium.h.

{ return graph_->isolate(); }

References graph_.

Referenced by Codegen().

Here is the caller graph for this function:

LookupConstant()

HConstant * v8::internal::LChunk::LookupConstant

(

LConstantOperand *

operand

)

const

Definition at line 402 of file lithium.cc.

                                                                 {
  return HConstant::cast(graph_->LookupValue(operand->index()));
}

References graph_.

LookupDestination()

int v8::internal::LChunk::LookupDestination

(

int

block_id

)

const

Definition at line 285 of file lithium.cc.

                                                {
  LLabel* cur = GetLabel(block_id);
  while (cur->replacement() != NULL) {
    cur = cur->replacement();
  }
  return cur->block_id();
}

References GetLabel(), and NULL.

Referenced by v8::internal::LControlInstruction< I, T >::FalseDestination(), and v8::internal::LControlInstruction< I, T >::TrueDestination().

Here is the call graph for this function:

Here is the caller graph for this function:

LookupLiteralRepresentation()

Representation v8::internal::LChunk::LookupLiteralRepresentation

(

LConstantOperand *

operand

)

const

Definition at line 407 of file lithium.cc.

                                     {
  return graph_->LookupValue(operand->index())->representation();
}

References graph_.

MarkEmptyBlocks()

void v8::internal::LChunk::MarkEmptyBlocks

(

)

Definition at line 300 of file lithium.cc.

                             {
  LPhase phase("L_Mark empty blocks", this);
  for (int i = 0; i < graph()->blocks()->length(); ++i) {
    HBasicBlock* block = graph()->blocks()->at(i);
    int first = block->first_instruction_index();
    int last = block->last_instruction_index();
    LInstruction* first_instr = instructions()->at(first);
    LInstruction* last_instr = instructions()->at(last);
 
    LLabel* label = LLabel::cast(first_instr);
    if (last_instr->IsGoto()) {
      LGoto* goto_instr = LGoto::cast(last_instr);
      if (label->IsRedundant() &&
          !label->is_loop_header()) {
        bool can_eliminate = true;
        for (int i = first + 1; i < last && can_eliminate; ++i) {
          LInstruction* cur = instructions()->at(i);
          if (cur->IsGap()) {
            LGap* gap = LGap::cast(cur);
            if (!gap->IsRedundant()) {
              can_eliminate = false;
            }
          } else {
            can_eliminate = false;
          }
        }
        if (can_eliminate) {
          label->set_replacement(GetLabel(goto_instr->block_id()));
        }
      }
    }
  }
}

References v8::internal::LGap::cast(), GetLabel(), graph(), instructions(), v8::internal::LInstruction::IsGap(), and v8::internal::LGap::IsRedundant().

Referenced by Codegen().

Here is the call graph for this function:

Here is the caller graph for this function:

NearestGapPos()

int v8::internal::LChunk::NearestGapPos

(

int

index

)

const

Definition at line 390 of file lithium.cc.

                                         {
  while (!IsGapAt(index)) index--;
  return index;
}

References IsGapAt().

Here is the call graph for this function:

NewChunk()

LChunk * v8::internal::LChunk::NewChunk ( HGraph *  graph )

static

Definition at line 434 of file lithium.cc.

                                      {
  DisallowHandleAllocation no_handles;
  DisallowHeapAllocation no_gc;
  graph->DisallowAddingNewValues();
  int values = graph->GetMaximumValueID();
  CompilationInfo* info = graph->info();
  if (values > LUnallocated::kMaxVirtualRegisters) {
    info->AbortOptimization(kNotEnoughVirtualRegistersForValues);
    return NULL;
  }
  LAllocator allocator(values, graph);
  LChunkBuilder builder(info, graph, &allocator);
  LChunk* chunk = builder.Build();
  if (chunk == NULL) return NULL;
 
  if (!allocator.Allocate(chunk)) {
    info->AbortOptimization(kNotEnoughVirtualRegistersRegalloc);
    return NULL;
  }
 
  chunk->set_allocated_double_registers(
      allocator.assigned_double_registers());
 
  return chunk;
}

References v8::internal::CompilationInfo::AbortOptimization(), graph(), info(), v8::internal::LUnallocated::kMaxVirtualRegisters, NULL, and set_allocated_double_registers().

Referenced by v8::internal::OptimizedCompileJob::OptimizeGraph(), and v8::internal::OptimizeGraph().

Here is the call graph for this function:

Here is the caller graph for this function:

ParameterAt()

int v8::internal::LChunk::ParameterAt

(

int

index

)

Definition at line 373 of file lithium.cc.

                                 {
  DCHECK(-1 <= index);  // -1 is the receiver.
  return (1 + info()->scope()->num_parameters() - index) *
      kPointerSize;
}

References DCHECK, info(), and v8::internal::kPointerSize.

Here is the call graph for this function:

pointer_maps()

const ZoneList<LPointerMap*>* v8::internal::LChunk::pointer_maps ( ) const

inline

Definition at line 640 of file lithium.h.

{ return &pointer_maps_; }

References pointer_maps_.

set_allocated_double_registers()

void v8::internal::LChunk::set_allocated_double_registers

(

BitVector *

allocated_registers

)

Definition at line 497 of file lithium.cc.

                                                                          {
  allocated_double_registers_ = allocated_registers;
  BitVector* doubles = allocated_double_registers();
  BitVector::Iterator iterator(doubles);
  while (!iterator.Done()) {
    if (info()->saves_caller_doubles()) {
      if (kDoubleSize == kPointerSize * 2) {
        spill_slot_count_ += 2;
      } else {
        spill_slot_count_++;
      }
    }
    iterator.Advance();
  }
}

References allocated_double_registers(), allocated_double_registers_, info(), v8::internal::kDoubleSize, v8::internal::kPointerSize, and spill_slot_count_.

Referenced by NewChunk().

Here is the call graph for this function:

Here is the caller graph for this function:

spill_slot_count()

int v8::internal::LChunk::spill_slot_count ( ) const

inline

Definition at line 630 of file lithium.h.

{ return spill_slot_count_; }

References spill_slot_count_.

zone()

Zone* v8::internal::LChunk::zone ( ) const

inline

Definition at line 667 of file lithium.h.

{ return info_->zone(); }

References info_, and v8::internal::CompilationInfo::zone().

Referenced by AddGapMove(), AddInlinedClosure(), AddInstruction(), and DefineConstantOperand().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

allocated_double_registers_

BitVector* v8::internal::LChunk::allocated_double_registers_

private

Definition at line 690 of file lithium.h.

Referenced by allocated_double_registers(), and set_allocated_double_registers().

deprecation_dependencies_

MapSet v8::internal::LChunk::deprecation_dependencies_

private

Definition at line 694 of file lithium.h.

Referenced by AddDeprecationDependency(), and CommitDependencies().

graph_

HGraph* const v8::internal::LChunk::graph_

private

Definition at line 689 of file lithium.h.

Referenced by GetLabel(), graph(), isolate(), LookupConstant(), and LookupLiteralRepresentation().

info_

CompilationInfo* v8::internal::LChunk::info_

private

Definition at line 688 of file lithium.h.

Referenced by AddDeprecationDependency(), AddStabilityDependency(), CommitDependencies(), info(), and zone().

inlined_closures_

ZoneList<Handle<JSFunction> > v8::internal::LChunk::inlined_closures_

private

Definition at line 693 of file lithium.h.

Referenced by AddInlinedClosure(), and inlined_closures().

instructions_

ZoneList<LInstruction*> v8::internal::LChunk::instructions_

private

Definition at line 691 of file lithium.h.

Referenced by AddInstruction(), GetGapAt(), GetLabel(), instructions(), and IsGapAt().

pointer_maps_

ZoneList<LPointerMap*> v8::internal::LChunk::pointer_maps_

private

Definition at line 692 of file lithium.h.

Referenced by AddInstruction(), and pointer_maps().

spill_slot_count_

int v8::internal::LChunk::spill_slot_count_

protected

Definition at line 679 of file lithium.h.

Referenced by set_allocated_double_registers(), and spill_slot_count().

stability_dependencies_

MapSet v8::internal::LChunk::stability_dependencies_

private

Definition at line 695 of file lithium.h.

Referenced by AddStabilityDependency(), and CommitDependencies().

---

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

• /mnt/V8SourceCode/src/lithium.h
• /mnt/V8SourceCode/src/lithium.cc