v8::internal::HRepresentationChangesPhase Class Reference

#include <hydrogen-representation-changes.h>

Inheritance diagram for v8::internal::HRepresentationChangesPhase:

Collaboration diagram for v8::internal::HRepresentationChangesPhase:

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

Private Member Functions
void	InsertRepresentationChangeForUse (HValue *value, HValue *use_value, int use_index, Representation to)
void	InsertRepresentationChangesForValue (HValue *value)

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

Detailed Description

Definition at line 14 of file hydrogen-representation-changes.h.

Constructor & Destructor Documentation

HRepresentationChangesPhase()

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

inlineexplicit

Definition at line 16 of file hydrogen-representation-changes.h.

      : HPhase("H_Representation changes", graph) { }

Member Function Documentation

InsertRepresentationChangeForUse()

void v8::internal::HRepresentationChangesPhase::InsertRepresentationChangeForUse ( HValue *  value, HValue *  use_value, int  use_index, Representation  to  )

private

Definition at line 10 of file hydrogen-representation-changes.cc.

                                                                        {
  // Insert the representation change right before its use. For phi-uses we
  // insert at the end of the corresponding predecessor.
  HInstruction* next = NULL;
  if (use_value->IsPhi()) {
    next = use_value->block()->predecessors()->at(use_index)->end();
  } else {
    next = HInstruction::cast(use_value);
  }
  // For constants we try to make the representation change at compile
  // time. When a representation change is not possible without loss of
  // information we treat constants like normal instructions and insert the
  // change instructions for them.
  HInstruction* new_value = NULL;
  bool is_truncating_to_smi = use_value->CheckFlag(HValue::kTruncatingToSmi);
  bool is_truncating_to_int = use_value->CheckFlag(HValue::kTruncatingToInt32);
  if (value->IsConstant()) {
    HConstant* constant = HConstant::cast(value);
    // Try to create a new copy of the constant with the new representation.
    if (is_truncating_to_int && to.IsInteger32()) {
      Maybe<HConstant*> res = constant->CopyToTruncatedInt32(graph()->zone());
      if (res.has_value) new_value = res.value;
    } else {
      new_value = constant->CopyToRepresentation(to, graph()->zone());
    }
  }
 
  if (new_value == NULL) {
    new_value = new(graph()->zone()) HChange(
        value, to, is_truncating_to_smi, is_truncating_to_int);
    if (!use_value->operand_position(use_index).IsUnknown()) {
      new_value->set_position(use_value->operand_position(use_index));
    } else {
      DCHECK(!FLAG_hydrogen_track_positions ||
             !graph()->info()->IsOptimizing());
    }
  }
 
  new_value->InsertBefore(next);
  use_value->SetOperandAt(use_index, new_value);
}

References v8::internal::HValue::block(), v8::internal::HValue::cast(), v8::internal::HValue::CheckFlag(), DCHECK, v8::internal::HPhase::graph(), v8::Maybe< T >::has_value, v8::internal::HInstruction::InsertBefore(), v8::internal::HValue::IsPhi(), v8::internal::HSourcePosition::IsUnknown(), v8::internal::HValue::kTruncatingToInt32, v8::internal::HValue::kTruncatingToSmi, NULL, v8::internal::HValue::operand_position(), v8::internal::HInstruction::set_position(), v8::internal::HValue::SetOperandAt(), to(), and v8::Maybe< T >::value.

Referenced by InsertRepresentationChangesForValue().

Here is the call graph for this function:

Here is the caller graph for this function:

InsertRepresentationChangesForValue()

void v8::internal::HRepresentationChangesPhase::InsertRepresentationChangesForValue ( HValue *  value )

private

Definition at line 63 of file hydrogen-representation-changes.cc.

                   {
  Representation r = value->representation();
  if (r.IsNone()) return;
  if (value->HasNoUses()) {
    if (value->IsForceRepresentation()) value->DeleteAndReplaceWith(NULL);
    return;
  }
 
  for (HUseIterator it(value->uses()); !it.Done(); it.Advance()) {
    HValue* use_value = it.value();
    int use_index = it.index();
    Representation req = use_value->RequiredInputRepresentation(use_index);
    if (req.IsNone() || req.Equals(r)) continue;
 
    // If this is an HForceRepresentation instruction, and an HChange has been
    // inserted above it, examine the input representation of the HChange. If
    // that's int32, and this HForceRepresentation use is int32, and int32 to
    // smi changes can't cause deoptimisation, set the input of the use to the
    // input of the HChange.
    if (value->IsForceRepresentation()) {
      HValue* input = HForceRepresentation::cast(value)->value();
      if (input->IsChange()) {
        HChange* change = HChange::cast(input);
        if (change->from().Equals(req) && IsNonDeoptingIntToSmiChange(change)) {
          use_value->SetOperandAt(use_index, change->value());
          continue;
        }
      }
    }
    InsertRepresentationChangeForUse(value, use_value, use_index, req);
  }
  if (value->HasNoUses()) {
    DCHECK(value->IsConstant() || value->IsForceRepresentation());
    value->DeleteAndReplaceWith(NULL);
  } else {
    // The only purpose of a HForceRepresentation is to represent the value
    // after the (possible) HChange instruction.  We make it disappear.
    if (value->IsForceRepresentation()) {
      value->DeleteAndReplaceWith(HForceRepresentation::cast(value)->value());
    }
  }
}

References DCHECK, v8::internal::HValue::DeleteAndReplaceWith(), v8::internal::Representation::Equals(), v8::internal::HValue::HasNoUses(), InsertRepresentationChangeForUse(), v8::internal::IsNonDeoptingIntToSmiChange(), v8::internal::Representation::IsNone(), NULL, v8::internal::HValue::representation(), v8::internal::HValue::RequiredInputRepresentation(), v8::internal::HValue::SetOperandAt(), and v8::internal::HValue::uses().

Referenced by Run().

Here is the call graph for this function:

Here is the caller graph for this function:

Run()

void v8::internal::HRepresentationChangesPhase::Run

(

)

Definition at line 108 of file hydrogen-representation-changes.cc.

                                      {
  // Compute truncation flag for phis: Initially assume that all
  // int32-phis allow truncation and iteratively remove the ones that
  // are used in an operation that does not allow a truncating
  // conversion.
  ZoneList<HPhi*> int_worklist(8, zone());
  ZoneList<HPhi*> smi_worklist(8, zone());
 
  const ZoneList<HPhi*>* phi_list(graph()->phi_list());
  for (int i = 0; i < phi_list->length(); i++) {
    HPhi* phi = phi_list->at(i);
    if (phi->representation().IsInteger32()) {
      phi->SetFlag(HValue::kTruncatingToInt32);
    } else if (phi->representation().IsSmi()) {
      phi->SetFlag(HValue::kTruncatingToSmi);
      phi->SetFlag(HValue::kTruncatingToInt32);
    }
  }
 
  for (int i = 0; i < phi_list->length(); i++) {
    HPhi* phi = phi_list->at(i);
    HValue* value = NULL;
    if (phi->representation().IsSmiOrInteger32() &&
        !phi->CheckUsesForFlag(HValue::kTruncatingToInt32, &value)) {
      int_worklist.Add(phi, zone());
      phi->ClearFlag(HValue::kTruncatingToInt32);
      if (FLAG_trace_representation) {
        PrintF("#%d Phi is not truncating Int32 because of #%d %s\n",
               phi->id(), value->id(), value->Mnemonic());
      }
    }
 
    if (phi->representation().IsSmi() &&
        !phi->CheckUsesForFlag(HValue::kTruncatingToSmi, &value)) {
      smi_worklist.Add(phi, zone());
      phi->ClearFlag(HValue::kTruncatingToSmi);
      if (FLAG_trace_representation) {
        PrintF("#%d Phi is not truncating Smi because of #%d %s\n",
               phi->id(), value->id(), value->Mnemonic());
      }
    }
  }
 
  while (!int_worklist.is_empty()) {
    HPhi* current = int_worklist.RemoveLast();
    for (int i = 0; i < current->OperandCount(); ++i) {
      HValue* input = current->OperandAt(i);
      if (input->IsPhi() &&
          input->representation().IsSmiOrInteger32() &&
          input->CheckFlag(HValue::kTruncatingToInt32)) {
        if (FLAG_trace_representation) {
          PrintF("#%d Phi is not truncating Int32 because of #%d %s\n",
                 input->id(), current->id(), current->Mnemonic());
        }
        input->ClearFlag(HValue::kTruncatingToInt32);
        int_worklist.Add(HPhi::cast(input), zone());
      }
    }
  }
 
  while (!smi_worklist.is_empty()) {
    HPhi* current = smi_worklist.RemoveLast();
    for (int i = 0; i < current->OperandCount(); ++i) {
      HValue* input = current->OperandAt(i);
      if (input->IsPhi() &&
          input->representation().IsSmi() &&
          input->CheckFlag(HValue::kTruncatingToSmi)) {
        if (FLAG_trace_representation) {
          PrintF("#%d Phi is not truncating Smi because of #%d %s\n",
                 input->id(), current->id(), current->Mnemonic());
        }
        input->ClearFlag(HValue::kTruncatingToSmi);
        smi_worklist.Add(HPhi::cast(input), zone());
      }
    }
  }
 
  const ZoneList<HBasicBlock*>* blocks(graph()->blocks());
  for (int i = 0; i < blocks->length(); ++i) {
    // Process phi instructions first.
    const HBasicBlock* block(blocks->at(i));
    const ZoneList<HPhi*>* phis = block->phis();
    for (int j = 0; j < phis->length(); j++) {
      InsertRepresentationChangesForValue(phis->at(j));
    }
 
    // Process normal instructions.
    for (HInstruction* current = block->first(); current != NULL; ) {
      HInstruction* next = current->next();
      InsertRepresentationChangesForValue(current);
      current = next;
    }
  }
}

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::List< T, AllocationPolicy >::at(), v8::internal::HValue::CheckFlag(), v8::internal::HValue::ClearFlag(), v8::internal::HPhase::graph(), v8::internal::HValue::id(), InsertRepresentationChangesForValue(), v8::internal::HValue::IsPhi(), v8::internal::Representation::IsSmi(), v8::internal::Representation::IsSmiOrInteger32(), v8::internal::HValue::kTruncatingToInt32, v8::internal::HValue::kTruncatingToSmi, v8::internal::HValue::Mnemonic(), v8::internal::HInstruction::next(), NULL, v8::internal::HValue::OperandAt(), v8::internal::PrintF(), and v8::internal::HValue::representation().

Here is the call graph for this function:

---

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

• /mnt/V8SourceCode/src/hydrogen-representation-changes.h
• /mnt/V8SourceCode/src/hydrogen-representation-changes.cc