v8::internal::HCanonicalizePhase Class Reference

#include <hydrogen-canonicalize.h>

Inheritance diagram for v8::internal::HCanonicalizePhase:

Collaboration diagram for v8::internal::HCanonicalizePhase:

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

Private Member Functions
	DISALLOW_COPY_AND_ASSIGN (HCanonicalizePhase)

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

Detailed Description

Definition at line 14 of file hydrogen-canonicalize.h.

Constructor & Destructor Documentation

HCanonicalizePhase()

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

inlineexplicit

Definition at line 16 of file hydrogen-canonicalize.h.

      : HPhase("H_Canonicalize", graph) { }

Member Function Documentation

DISALLOW_COPY_AND_ASSIGN()

v8::internal::HCanonicalizePhase::DISALLOW_COPY_AND_ASSIGN ( HCanonicalizePhase  )

private

Run()

void v8::internal::HCanonicalizePhase::Run

(

)

Definition at line 11 of file hydrogen-canonicalize.cc.

                             {
  const ZoneList<HBasicBlock*>* blocks(graph()->blocks());
  // Before removing no-op instructions, save their semantic value.
  // We must be careful not to set the flag unnecessarily, because GVN
  // cannot identify two instructions when their flag value differs.
  for (int i = 0; i < blocks->length(); ++i) {
    for (HInstructionIterator it(blocks->at(i)); !it.Done(); it.Advance()) {
      HInstruction* instr = it.Current();
      if (instr->IsArithmeticBinaryOperation()) {
        if (instr->representation().IsInteger32()) {
          if (instr->HasAtLeastOneUseWithFlagAndNoneWithout(
                  HInstruction::kTruncatingToInt32)) {
            instr->SetFlag(HInstruction::kAllUsesTruncatingToInt32);
          }
        } else if (instr->representation().IsSmi()) {
          if (instr->HasAtLeastOneUseWithFlagAndNoneWithout(
                  HInstruction::kTruncatingToSmi)) {
            instr->SetFlag(HInstruction::kAllUsesTruncatingToSmi);
          } else if (instr->HasAtLeastOneUseWithFlagAndNoneWithout(
                         HInstruction::kTruncatingToInt32)) {
            // Avoid redundant minus zero check
            instr->SetFlag(HInstruction::kAllUsesTruncatingToInt32);
          }
        }
      }
    }
  }
 
  // Perform actual Canonicalization pass.
  HRedundantPhiEliminationPhase redundant_phi_eliminator(graph());
  for (int i = 0; i < blocks->length(); ++i) {
    // Eliminate redundant phis in the block first; changes to their inputs
    // might have made them redundant, and eliminating them creates more
    // opportunities for constant folding and strength reduction.
    redundant_phi_eliminator.ProcessBlock(blocks->at(i));
    // Now canonicalize each instruction.
    for (HInstructionIterator it(blocks->at(i)); !it.Done(); it.Advance()) {
      HInstruction* instr = it.Current();
      HValue* value = instr->Canonicalize();
      if (value != instr) instr->DeleteAndReplaceWith(value);
    }
  }
}

References v8::internal::List< T, AllocationPolicy >::at(), v8::internal::HValue::Canonicalize(), v8::internal::HValue::DeleteAndReplaceWith(), v8::internal::HPhase::graph(), v8::internal::HValue::HasAtLeastOneUseWithFlagAndNoneWithout(), v8::internal::Representation::IsInteger32(), v8::internal::Representation::IsSmi(), v8::internal::HValue::kAllUsesTruncatingToInt32, v8::internal::HValue::kAllUsesTruncatingToSmi, v8::internal::HValue::kTruncatingToInt32, v8::internal::HValue::kTruncatingToSmi, v8::internal::HRedundantPhiEliminationPhase::ProcessBlock(), v8::internal::HValue::representation(), and v8::internal::HValue::SetFlag().

Here is the call graph for this function:

---

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

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