v8::internal::BoundsCheckBbData Class Reference

Inheritance diagram for v8::internal::BoundsCheckBbData:

Collaboration diagram for v8::internal::BoundsCheckBbData:

Public Member Functions
BoundsCheckKey *	Key () const
int32_t	LowerOffset () const
int32_t	UpperOffset () const
HBasicBlock *	BasicBlock () const
HBoundsCheck *	LowerCheck () const
HBoundsCheck *	UpperCheck () const
BoundsCheckBbData *	NextInBasicBlock () const
BoundsCheckBbData *	FatherInDominatorTree () const
bool	OffsetIsCovered (int32_t offset) const
bool	HasSingleCheck ()
void	UpdateUpperOffsets (HBoundsCheck *check, int32_t offset)
void	UpdateLowerOffsets (HBoundsCheck *check, int32_t offset)
void	CoverCheck (HBoundsCheck *new_check, int32_t new_offset)
	BoundsCheckBbData (BoundsCheckKey *key, int32_t lower_offset, int32_t upper_offset, HBasicBlock *bb, HBoundsCheck *lower_check, HBoundsCheck *upper_check, BoundsCheckBbData *next_in_bb, BoundsCheckBbData *father_in_dt)
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)

Private Member Functions
void	MoveIndexIfNecessary (HValue *index_raw, HBoundsCheck *insert_before, HInstruction *end_of_scan_range)
void	TightenCheck (HBoundsCheck *original_check, HBoundsCheck *tighter_check, int32_t new_offset)
	DISALLOW_COPY_AND_ASSIGN (BoundsCheckBbData)

Private Attributes
BoundsCheckKey *	key_
int32_t	lower_offset_
int32_t	upper_offset_
HBasicBlock *	basic_block_
HBoundsCheck *	lower_check_
HBoundsCheck *	upper_check_
BoundsCheckBbData *	next_in_bb_
BoundsCheckBbData *	father_in_dt_

Detailed Description

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

Constructor & Destructor Documentation

BoundsCheckBbData()

v8::internal::BoundsCheckBbData::BoundsCheckBbData ( BoundsCheckKey *  key, int32_t  lower_offset, int32_t  upper_offset, HBasicBlock *  bb, HBoundsCheck *  lower_check, HBoundsCheck *  upper_check, BoundsCheckBbData *  next_in_bb, BoundsCheckBbData *  father_in_dt  )

inline

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

      : key_(key),
        lower_offset_(lower_offset),
        upper_offset_(upper_offset),
        basic_block_(bb),
        lower_check_(lower_check),
        upper_check_(upper_check),
        next_in_bb_(next_in_bb),
        father_in_dt_(father_in_dt) { }

Member Function Documentation

BasicBlock()

HBasicBlock* v8::internal::BoundsCheckBbData::BasicBlock ( ) const

inline

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

{ return basic_block_; }

References basic_block_.

Referenced by v8::internal::HBoundsCheckEliminationPhase::PreProcessBlock().

Here is the caller graph for this function:

CoverCheck()

void v8::internal::BoundsCheckBbData::CoverCheck ( HBoundsCheck *  new_check, int32_t  new_offset  )

inline

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

                                      {
    DCHECK(new_check->index()->representation().IsSmiOrInteger32());
    bool keep_new_check = false;
 
    if (new_offset > upper_offset_) {
      upper_offset_ = new_offset;
      if (HasSingleCheck()) {
        keep_new_check = true;
        upper_check_ = new_check;
      } else {
        TightenCheck(upper_check_, new_check, new_offset);
        UpdateUpperOffsets(upper_check_, upper_offset_);
      }
    } else if (new_offset < lower_offset_) {
      lower_offset_ = new_offset;
      if (HasSingleCheck()) {
        keep_new_check = true;
        lower_check_ = new_check;
      } else {
        TightenCheck(lower_check_, new_check, new_offset);
        UpdateLowerOffsets(lower_check_, lower_offset_);
      }
    } else {
      // Should never have called CoverCheck() in this case.
      UNREACHABLE();
    }
 
    if (!keep_new_check) {
      if (FLAG_trace_bce) {
        base::OS::Print("Eliminating check #%d after tightening\n",
                        new_check->id());
      }
      new_check->block()->graph()->isolate()->counters()->
          bounds_checks_eliminated()->Increment();
      new_check->DeleteAndReplaceWith(new_check->ActualValue());
    } else {
      HBoundsCheck* first_check = new_check == lower_check_ ? upper_check_
                                                            : lower_check_;
      if (FLAG_trace_bce) {
        base::OS::Print("Moving second check #%d after first check #%d\n",
                        new_check->id(), first_check->id());
      }
      // The length is guaranteed to be live at first_check.
      DCHECK(new_check->length() == first_check->length());
      HInstruction* old_position = new_check->next();
      new_check->Unlink();
      new_check->InsertAfter(first_check);
      MoveIndexIfNecessary(new_check->index(), new_check, old_position);
    }
  }

References DCHECK, HasSingleCheck(), lower_check_, lower_offset_, MoveIndexIfNecessary(), v8::internal::HInstruction::next(), v8::base::OS::Print(), TightenCheck(), v8::internal::HInstruction::Unlink(), UNREACHABLE, UpdateLowerOffsets(), UpdateUpperOffsets(), upper_check_, and upper_offset_.

Referenced by v8::internal::HBoundsCheckEliminationPhase::PreProcessBlock().

Here is the call graph for this function:

Here is the caller graph for this function:

DISALLOW_COPY_AND_ASSIGN()

v8::internal::BoundsCheckBbData::DISALLOW_COPY_AND_ASSIGN ( BoundsCheckBbData  )

private

FatherInDominatorTree()

BoundsCheckBbData* v8::internal::BoundsCheckBbData::FatherInDominatorTree ( ) const

inline

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

{ return father_in_dt_; }

References father_in_dt_.

Referenced by v8::internal::HBoundsCheckEliminationPhase::PostProcessBlock(), UpdateLowerOffsets(), and UpdateUpperOffsets().

Here is the caller graph for this function:

HasSingleCheck()

bool v8::internal::BoundsCheckBbData::HasSingleCheck ( )

inline

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

{ return lower_check_ == upper_check_; }

References lower_check_, and upper_check_.

Referenced by CoverCheck().

Here is the caller graph for this function:

Key()

BoundsCheckKey* v8::internal::BoundsCheckBbData::Key ( ) const

inline

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

{ return key_; }

References key_.

Referenced by v8::internal::HBoundsCheckEliminationPhase::PostProcessBlock().

Here is the caller graph for this function:

LowerCheck()

HBoundsCheck* v8::internal::BoundsCheckBbData::LowerCheck ( ) const

inline

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

{ return lower_check_; }

References lower_check_.

Referenced by v8::internal::HBoundsCheckEliminationPhase::PreProcessBlock(), and UpdateLowerOffsets().

Here is the caller graph for this function:

LowerOffset()

int32_t v8::internal::BoundsCheckBbData::LowerOffset ( ) const

inline

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

{ return lower_offset_; }

References lower_offset_.

Referenced by OffsetIsCovered(), and v8::internal::HBoundsCheckEliminationPhase::PreProcessBlock().

Here is the caller graph for this function:

MoveIndexIfNecessary()

void v8::internal::BoundsCheckBbData::MoveIndexIfNecessary ( HValue *  index_raw, HBoundsCheck *  insert_before, HInstruction *  end_of_scan_range  )

inlineprivate

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

                                                             {
    // index_raw can be HAdd(index_base, offset), HSub(index_base, offset),
    // HConstant(offset) or index_base directly.
    // In the latter case, no need to move anything.
    if (index_raw->IsAdd() || index_raw->IsSub()) {
      HArithmeticBinaryOperation* index =
          HArithmeticBinaryOperation::cast(index_raw);
      HValue* left_input = index->left();
      HValue* right_input = index->right();
      bool must_move_index = false;
      bool must_move_left_input = false;
      bool must_move_right_input = false;
      for (HInstruction* cursor = end_of_scan_range; cursor != insert_before;) {
        if (cursor == left_input) must_move_left_input = true;
        if (cursor == right_input) must_move_right_input = true;
        if (cursor == index) must_move_index = true;
        if (cursor->previous() == NULL) {
          cursor = cursor->block()->dominator()->end();
        } else {
          cursor = cursor->previous();
        }
      }
      if (must_move_index) {
        index->Unlink();
        index->InsertBefore(insert_before);
      }
      // The BCE algorithm only selects mergeable bounds checks that share
      // the same "index_base", so we'll only ever have to move constants.
      if (must_move_left_input) {
        HConstant::cast(left_input)->Unlink();
        HConstant::cast(left_input)->InsertBefore(index);
      }
      if (must_move_right_input) {
        HConstant::cast(right_input)->Unlink();
        HConstant::cast(right_input)->InsertBefore(index);
      }
    } else if (index_raw->IsConstant()) {
      HConstant* index = HConstant::cast(index_raw);
      bool must_move = false;
      for (HInstruction* cursor = end_of_scan_range; cursor != insert_before;) {
        if (cursor == index) must_move = true;
        if (cursor->previous() == NULL) {
          cursor = cursor->block()->dominator()->end();
        } else {
          cursor = cursor->previous();
        }
      }
      if (must_move) {
        index->Unlink();
        index->InsertBefore(insert_before);
      }
    }
  }

References v8::internal::HValue::cast(), v8::internal::HInstruction::InsertBefore(), v8::internal::HBinaryOperation::left(), NULL, v8::internal::HBinaryOperation::right(), and v8::internal::HInstruction::Unlink().

Referenced by CoverCheck(), and TightenCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

NextInBasicBlock()

BoundsCheckBbData* v8::internal::BoundsCheckBbData::NextInBasicBlock ( ) const

inline

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

{ return next_in_bb_; }

References next_in_bb_.

Referenced by v8::internal::HBoundsCheckEliminationPhase::PostProcessBlock().

Here is the caller graph for this function:

OffsetIsCovered()

bool v8::internal::BoundsCheckBbData::OffsetIsCovered ( int32_t  offset ) const

inline

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

                                             {
    return offset >= LowerOffset() && offset <= UpperOffset();
  }

References LowerOffset(), and UpperOffset().

Referenced by v8::internal::HBoundsCheckEliminationPhase::PreProcessBlock().

Here is the call graph for this function:

Here is the caller graph for this function:

TightenCheck()

void v8::internal::BoundsCheckBbData::TightenCheck ( HBoundsCheck *  original_check, HBoundsCheck *  tighter_check, int32_t  new_offset  )

inlineprivate

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

                                        {
    DCHECK(original_check->length() == tighter_check->length());
    MoveIndexIfNecessary(tighter_check->index(), original_check, tighter_check);
    original_check->ReplaceAllUsesWith(original_check->index());
    original_check->SetOperandAt(0, tighter_check->index());
    if (FLAG_trace_bce) {
      base::OS::Print("Tightened check #%d with offset %d from #%d\n",
                      original_check->id(), new_offset, tighter_check->id());
    }
  }

References DCHECK, MoveIndexIfNecessary(), and v8::base::OS::Print().

Referenced by CoverCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateLowerOffsets()

void v8::internal::BoundsCheckBbData::UpdateLowerOffsets ( HBoundsCheck *  check, int32_t  offset  )

inline

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

                                                               {
    BoundsCheckBbData* data = FatherInDominatorTree();
    while (data != NULL && data->LowerCheck() == check) {
      DCHECK(data->lower_offset_ > offset);
      data->lower_offset_ = offset;
      data = data->FatherInDominatorTree();
    }
  }

References DCHECK, FatherInDominatorTree(), lower_offset_, LowerCheck(), and NULL.

Referenced by CoverCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateUpperOffsets()

void v8::internal::BoundsCheckBbData::UpdateUpperOffsets ( HBoundsCheck *  check, int32_t  offset  )

inline

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

                                                               {
    BoundsCheckBbData* data = FatherInDominatorTree();
    while (data != NULL && data->UpperCheck() == check) {
      DCHECK(data->upper_offset_ < offset);
      data->upper_offset_ = offset;
      data = data->FatherInDominatorTree();
    }
  }

References DCHECK, FatherInDominatorTree(), NULL, upper_offset_, and UpperCheck().

Referenced by CoverCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

UpperCheck()

HBoundsCheck* v8::internal::BoundsCheckBbData::UpperCheck ( ) const

inline

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

{ return upper_check_; }

References upper_check_.

Referenced by v8::internal::HBoundsCheckEliminationPhase::PreProcessBlock(), and UpdateUpperOffsets().

Here is the caller graph for this function:

UpperOffset()

int32_t v8::internal::BoundsCheckBbData::UpperOffset ( ) const

inline

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

{ return upper_offset_; }

References upper_offset_.

Referenced by OffsetIsCovered(), and v8::internal::HBoundsCheckEliminationPhase::PreProcessBlock().

Here is the caller graph for this function:

Member Data Documentation

basic_block_

HBasicBlock* v8::internal::BoundsCheckBbData::basic_block_

private

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

Referenced by BasicBlock().

father_in_dt_

BoundsCheckBbData* v8::internal::BoundsCheckBbData::father_in_dt_

private

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

Referenced by FatherInDominatorTree().

key_

BoundsCheckKey* v8::internal::BoundsCheckBbData::key_

private

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

Referenced by Key().

lower_check_

HBoundsCheck* v8::internal::BoundsCheckBbData::lower_check_

private

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

Referenced by CoverCheck(), HasSingleCheck(), and LowerCheck().

lower_offset_

int32_t v8::internal::BoundsCheckBbData::lower_offset_

private

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

Referenced by CoverCheck(), LowerOffset(), and UpdateLowerOffsets().

next_in_bb_

BoundsCheckBbData* v8::internal::BoundsCheckBbData::next_in_bb_

private

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

Referenced by NextInBasicBlock().

upper_check_

HBoundsCheck* v8::internal::BoundsCheckBbData::upper_check_

private

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

Referenced by CoverCheck(), HasSingleCheck(), and UpperCheck().

upper_offset_

int32_t v8::internal::BoundsCheckBbData::upper_offset_

private

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

Referenced by CoverCheck(), UpdateUpperOffsets(), and UpperOffset().

---

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

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