v8::internal::HBoundsCheckEliminationPhase Class Reference

#include <hydrogen-bce.h>

Inheritance diagram for v8::internal::HBoundsCheckEliminationPhase:

Collaboration diagram for v8::internal::HBoundsCheckEliminationPhase:

Public Member Functions
	HBoundsCheckEliminationPhase (HGraph *graph)
void	Run ()
Public Member Functions inherited from v8::internal::HPhase
	HPhase (const char *name, HGraph *graph)
	~HPhase ()

Private Member Functions
void	EliminateRedundantBoundsChecks (HBasicBlock *bb)
BoundsCheckBbData *	PreProcessBlock (HBasicBlock *bb)
void	PostProcessBlock (HBasicBlock *bb, BoundsCheckBbData *data)
	DISALLOW_COPY_AND_ASSIGN (HBoundsCheckEliminationPhase)

Private Attributes
BoundsCheckTable	table_

Additional Inherited Members
Protected Member Functions inherited from v8::internal::HPhase
HGraph *	graph () const

Detailed Description

Definition at line 29 of file hydrogen-bce.h.

Constructor & Destructor Documentation

HBoundsCheckEliminationPhase()

v8::internal::HBoundsCheckEliminationPhase::HBoundsCheckEliminationPhase ( HGraph *  graph )

inlineexplicit

Definition at line 31 of file hydrogen-bce.h.

      : HPhase("H_Bounds checks elimination", graph), table_(zone()) { }

Member Function Documentation

DISALLOW_COPY_AND_ASSIGN()

v8::internal::HBoundsCheckEliminationPhase::DISALLOW_COPY_AND_ASSIGN ( HBoundsCheckEliminationPhase  )

private

EliminateRedundantBoundsChecks()

void v8::internal::HBoundsCheckEliminationPhase::EliminateRedundantBoundsChecks ( HBasicBlock *  bb )

private

Definition at line 339 of file hydrogen-bce.cc.

                        {
  // Allocate the stack.
  HBoundsCheckEliminationState* stack =
    zone()->NewArray<HBoundsCheckEliminationState>(graph()->blocks()->length());
 
  // Explicitly push the entry block.
  stack[0].block_ = entry;
  stack[0].bb_data_list_ = PreProcessBlock(entry);
  stack[0].index_ = 0;
  int stack_depth = 1;
 
  // Implement depth-first traversal with a stack.
  while (stack_depth > 0) {
    int current = stack_depth - 1;
    HBoundsCheckEliminationState* state = &stack[current];
    const ZoneList<HBasicBlock*>* children = state->block_->dominated_blocks();
 
    if (state->index_ < children->length()) {
      // Recursively visit children blocks.
      HBasicBlock* child = children->at(state->index_++);
      int next = stack_depth++;
      stack[next].block_ = child;
      stack[next].bb_data_list_ = PreProcessBlock(child);
      stack[next].index_ = 0;
    } else {
      // Finished with all children; post process the block.
      PostProcessBlock(state->block_, state->bb_data_list_);
      stack_depth--;
    }
  }
}

References v8::internal::List< T, AllocationPolicy >::at(), v8::internal::HBoundsCheckEliminationState::bb_data_list_, v8::internal::HBoundsCheckEliminationState::block_, v8::internal::HPhase::graph(), v8::internal::HBoundsCheckEliminationState::index_, PostProcessBlock(), and PreProcessBlock().

Referenced by Run().

Here is the call graph for this function:

Here is the caller graph for this function:

PostProcessBlock()

void v8::internal::HBoundsCheckEliminationPhase::PostProcessBlock ( HBasicBlock *  bb, BoundsCheckBbData *  data  )

private

Definition at line 453 of file hydrogen-bce.cc.

                                                 {
  while (data != NULL) {
    if (data->FatherInDominatorTree()) {
      table_.Insert(data->Key(), data->FatherInDominatorTree(), zone());
    } else {
      table_.Delete(data->Key());
    }
    data = data->NextInBasicBlock();
  }
}

References v8::internal::BoundsCheckBbData::FatherInDominatorTree(), v8::internal::BoundsCheckBbData::Key(), v8::internal::BoundsCheckBbData::NextInBasicBlock(), NULL, and table_.

Referenced by EliminateRedundantBoundsChecks().

Here is the call graph for this function:

Here is the caller graph for this function:

PreProcessBlock()

BoundsCheckBbData * v8::internal::HBoundsCheckEliminationPhase::PreProcessBlock ( HBasicBlock *  bb )

private

Definition at line 373 of file hydrogen-bce.cc.

                     {
  BoundsCheckBbData* bb_data_list = NULL;
 
  for (HInstructionIterator it(bb); !it.Done(); it.Advance()) {
    HInstruction* i = it.Current();
    if (!i->IsBoundsCheck()) continue;
 
    HBoundsCheck* check = HBoundsCheck::cast(i);
    int32_t offset;
    BoundsCheckKey* key =
        BoundsCheckKey::Create(zone(), check, &offset);
    if (key == NULL) continue;
    BoundsCheckBbData** data_p = table_.LookupOrInsert(key, zone());
    BoundsCheckBbData* data = *data_p;
    if (data == NULL) {
      bb_data_list = new(zone()) BoundsCheckBbData(key,
                                                   offset,
                                                   offset,
                                                   bb,
                                                   check,
                                                   check,
                                                   bb_data_list,
                                                   NULL);
      *data_p = bb_data_list;
      if (FLAG_trace_bce) {
        base::OS::Print("Fresh bounds check data for block #%d: [%d]\n",
                        bb->block_id(), offset);
      }
    } else if (data->OffsetIsCovered(offset)) {
      bb->graph()->isolate()->counters()->
          bounds_checks_eliminated()->Increment();
      if (FLAG_trace_bce) {
        base::OS::Print("Eliminating bounds check #%d, offset %d is covered\n",
                        check->id(), offset);
      }
      check->DeleteAndReplaceWith(check->ActualValue());
    } else if (data->BasicBlock() == bb) {
      // TODO(jkummerow): I think the following logic would be preferable:
      // if (data->Basicblock() == bb ||
      //     graph()->use_optimistic_licm() ||
      //     bb->IsLoopSuccessorDominator()) {
      //   data->CoverCheck(check, offset)
      // } else {
      //   /* add pristine BCBbData like in (data == NULL) case above */
      // }
      // Even better would be: distinguish between read-only dominator-imposed
      // knowledge and modifiable upper/lower checks.
      // What happens currently is that the first bounds check in a dominated
      // block will stay around while any further checks are hoisted out,
      // which doesn't make sense. Investigate/fix this in a future CL.
      data->CoverCheck(check, offset);
    } else if (graph()->use_optimistic_licm() ||
               bb->IsLoopSuccessorDominator()) {
      int32_t new_lower_offset = offset < data->LowerOffset()
          ? offset
          : data->LowerOffset();
      int32_t new_upper_offset = offset > data->UpperOffset()
          ? offset
          : data->UpperOffset();
      bb_data_list = new(zone()) BoundsCheckBbData(key,
                                                   new_lower_offset,
                                                   new_upper_offset,
                                                   bb,
                                                   data->LowerCheck(),
                                                   data->UpperCheck(),
                                                   bb_data_list,
                                                   data);
      if (FLAG_trace_bce) {
        base::OS::Print("Updated bounds check data for block #%d: [%d - %d]\n",
                        bb->block_id(), new_lower_offset, new_upper_offset);
      }
      table_.Insert(key, bb_data_list, zone());
    }
  }
 
  return bb_data_list;
}

References v8::internal::BoundsCheckBbData::BasicBlock(), v8::internal::BoundsCheckBbData::CoverCheck(), v8::internal::BoundsCheckKey::Create(), v8::internal::HPhase::graph(), v8::internal::BoundsCheckBbData::LowerCheck(), v8::internal::BoundsCheckBbData::LowerOffset(), NULL, v8::internal::BoundsCheckBbData::OffsetIsCovered(), v8::base::OS::Print(), table_, v8::internal::BoundsCheckBbData::UpperCheck(), and v8::internal::BoundsCheckBbData::UpperOffset().

Referenced by EliminateRedundantBoundsChecks().

Here is the call graph for this function:

Here is the caller graph for this function:

Run()

void v8::internal::HBoundsCheckEliminationPhase::Run ( )

inline

Definition at line 34 of file hydrogen-bce.h.

             {
    EliminateRedundantBoundsChecks(graph()->entry_block());
  }

References EliminateRedundantBoundsChecks(), and v8::internal::HPhase::graph().

Here is the call graph for this function:

Member Data Documentation

table_

BoundsCheckTable v8::internal::HBoundsCheckEliminationPhase::table_

private

Definition at line 43 of file hydrogen-bce.h.

Referenced by PostProcessBlock(), and PreProcessBlock().

---

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

• /mnt/V8SourceCode/src/hydrogen-bce.h
• /mnt/V8SourceCode/src/hydrogen-bce.cc