#include <hydrogen-store-elimination.h>

Inheritance diagram for v8::internal::HStoreEliminationPhase:

Collaboration diagram for v8::internal::HStoreEliminationPhase:

Public Member Functions
	HStoreEliminationPhase (HGraph *graph)

void	Run ()

Public Member Functions inherited from v8::internal::HPhase
	HPhase (const char name, HGraph graph)

	~HPhase ()

Private Member Functions
void	ProcessStore (HStoreNamedField *store)

void	ProcessLoad (HLoadNamedField *load)

void	ProcessInstr (HInstruction *instr, GVNFlagSet flags)

Private Attributes
ZoneList< HStoreNamedField * >	unobserved_

HAliasAnalyzer *	aliasing_

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

Detailed Description

Definition at line 14 of file hydrogen-store-elimination.h.

Constructor & Destructor Documentation

◆ HStoreEliminationPhase()

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

inlineexplicit

Definition at line 16 of file hydrogen-store-elimination.h.

     : HPhase("H_Store elimination", graph),
       unobserved_(10, zone()),
       aliasing_() { }

Member Function Documentation

◆ ProcessInstr()

void v8::internal::HStoreEliminationPhase::ProcessInstr	(	HInstruction *	instr,
		GVNFlagSet	flags
	)

private

Definition at line 98 of file hydrogen-store-elimination.cc.

                       {
   if (unobserved_.length() == 0) return;  // Nothing to do.
   if (instr->CanDeoptimize()) {
     TRACE(("-- Observed stores at I%d (%s might deoptimize)\n",
            instr->id(), instr->Mnemonic()));
     unobserved_.Rewind(0);
     return;
   }
   if (instr->CheckChangesFlag(kNewSpacePromotion)) {
     TRACE(("-- Observed stores at I%d (%s might GC)\n",
            instr->id(), instr->Mnemonic()));
     unobserved_.Rewind(0);
     return;
   }
   if (instr->DependsOnFlags().ContainsAnyOf(flags)) {
     TRACE(("-- Observed stores at I%d (GVN flags of %s)\n",
            instr->id(), instr->Mnemonic()));
     unobserved_.Rewind(0);
     return;
   }
 }

References v8::internal::HInstruction::CanDeoptimize(), v8::internal::HValue::CheckChangesFlag(), v8::internal::EnumSet< E, T >::ContainsAnyOf(), v8::internal::HValue::DependsOnFlags(), v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::HValue::id(), v8::internal::HValue::Mnemonic(), TRACE, and unobserved_.

Referenced by Run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ProcessLoad()

void v8::internal::HStoreEliminationPhase::ProcessLoad ( HLoadNamedField * load )

private

Definition at line 82 of file hydrogen-store-elimination.cc.

                                                               {
   HValue* object = load->object()->ActualValue();
   int i = 0;
   while (i < unobserved_.length()) {
     HStoreNamedField* prev = unobserved_.at(i);
     if (aliasing_->MayAlias(object, prev->object()->ActualValue()) &&
         load->access().Equals(prev->access())) {
       TRACE(("-- Observed store S%d by load L%d\n", prev->id(), load->id()));
       unobserved_.Remove(i);
     } else {
       i++;
     }
   }
 }

References v8::internal::HValue::ActualValue(), aliasing_, v8::internal::List< T, AllocationPolicy >::at(), v8::internal::HAliasAnalyzer::MayAlias(), v8::internal::List< T, AllocationPolicy >::Remove(), TRACE, and unobserved_.

Referenced by Run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ProcessStore()

void v8::internal::HStoreEliminationPhase::ProcessStore ( HStoreNamedField * store )

private

Definition at line 57 of file hydrogen-store-elimination.cc.

                                                                  {
   HValue* object = store->object()->ActualValue();
   int i = 0;
   while (i < unobserved_.length()) {
     HStoreNamedField* prev = unobserved_.at(i);
     if (aliasing_->MustAlias(object, prev->object()->ActualValue()) &&
         prev->CanBeReplacedWith(store)) {
       // This store is guaranteed to overwrite the previous store.
       prev->DeleteAndReplaceWith(NULL);
       TRACE(("++ Unobserved store S%d overwritten by S%d\n",
              prev->id(), store->id()));
       unobserved_.Remove(i);
     } else {
       // TODO(titzer): remove map word clearing from folded allocations.
       i++;
     }
   }
   // Only non-transitioning stores are removable.
   if (!store->has_transition()) {
     TRACE(("-- Might remove store S%d\n", store->id()));
     unobserved_.Add(store, zone());
   }
 }

References v8::internal::HValue::ActualValue(), v8::internal::List< T, AllocationPolicy >::Add(), aliasing_, v8::internal::List< T, AllocationPolicy >::at(), v8::internal::HAliasAnalyzer::MustAlias(), NULL, v8::internal::List< T, AllocationPolicy >::Remove(), TRACE, and unobserved_.

Referenced by Run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Run()

void v8::internal::HStoreEliminationPhase::Run ( )

Definition at line 14 of file hydrogen-store-elimination.cc.

                                  {
   GVNFlagSet flags;  // Use GVN flags as an approximation for some instructions.
   flags.RemoveAll();
  
   flags.Add(kArrayElements);
   flags.Add(kArrayLengths);
   flags.Add(kStringLengths);
   flags.Add(kBackingStoreFields);
   flags.Add(kDoubleArrayElements);
   flags.Add(kDoubleFields);
   flags.Add(kElementsPointer);
   flags.Add(kInobjectFields);
   flags.Add(kExternalMemory);
   flags.Add(kStringChars);
   flags.Add(kTypedArrayElements);
  
   for (int i = 0; i < graph()->blocks()->length(); i++) {
     unobserved_.Rewind(0);
     HBasicBlock* block = graph()->blocks()->at(i);
     if (!block->IsReachable()) continue;
     for (HInstructionIterator it(block); !it.Done(); it.Advance()) {
       HInstruction* instr = it.Current();
       if (instr->CheckFlag(HValue::kIsDead)) continue;
  
       // TODO(titzer): eliminate unobserved HStoreKeyed instructions too.
       switch (instr->opcode()) {
         case HValue::kStoreNamedField:
           // Remove any unobserved stores overwritten by this store.
           ProcessStore(HStoreNamedField::cast(instr));
           break;
         case HValue::kLoadNamedField:
           // Observe any unobserved stores on this object + field.
           ProcessLoad(HLoadNamedField::cast(instr));
           break;
         default:
           ProcessInstr(instr, flags);
           break;
       }
     }
   }
 }