v8::internal::compiler::RepresentationSelector Class Reference

Collaboration diagram for v8::internal::compiler::RepresentationSelector:

Classes
struct	NodeInfo

Public Member Functions
	RepresentationSelector (JSGraph *jsgraph, Zone *zone, RepresentationChanger *changer)
void	Run (SimplifiedLowering *lowering)
void	Enqueue (Node *node, MachineTypeUnion use=0)
bool	lower ()
void	Enqueue (Node *node, MachineType use)
void	SetOutput (Node *node, MachineTypeUnion output)
bool	BothInputsAre (Node *node, Type *type)
void	ProcessInput (Node *node, int index, MachineTypeUnion use)
void	ProcessRemainingInputs (Node *node, int index)
void	VisitInputs (Node *node)
void	VisitBinop (Node *node, MachineTypeUnion input_use, MachineTypeUnion output)
void	VisitUnop (Node *node, MachineTypeUnion input_use, MachineTypeUnion output)
void	VisitLeaf (Node *node, MachineTypeUnion output)
void	VisitFloat64Binop (Node *node)
void	VisitInt32Binop (Node *node)
void	VisitUint32Binop (Node *node)
void	VisitInt64Binop (Node *node)
void	VisitUint64Binop (Node *node)
void	VisitFloat64Cmp (Node *node)
void	VisitInt32Cmp (Node *node)
void	VisitUint32Cmp (Node *node)
void	VisitInt64Cmp (Node *node)
void	VisitUint64Cmp (Node *node)
void	VisitPhi (Node *node, MachineTypeUnion use, SimplifiedLowering *lowering)
const Operator *	Int32Op (Node *node)
const Operator *	Uint32Op (Node *node)
const Operator *	Float64Op (Node *node)
void	VisitNode (Node *node, MachineTypeUnion use, SimplifiedLowering *lowering)
void	DeferReplacement (Node *node, Node *replacement)
void	PrintUseInfo (Node *node)
void	PrintInfo (MachineTypeUnion info)

Private Member Functions
NodeInfo *	GetInfo (Node *node)
MachineTypeUnion	GetUseInfo (Node *node)

Private Attributes
JSGraph *	jsgraph_
int	count_
NodeInfo *	info_
NodeVector	nodes_
NodeVector	replacements_
bool	contains_js_nodes_
Phase	phase_
RepresentationChanger *	changer_
ZoneQueue< Node * >	queue_

Detailed Description

Definition at line 52 of file simplified-lowering.cc.

Constructor & Destructor Documentation

RepresentationSelector()

v8::internal::compiler::RepresentationSelector::RepresentationSelector ( JSGraph *  jsgraph, Zone *  zone, RepresentationChanger *  changer  )

inline

Definition at line 62 of file simplified-lowering.cc.

      : jsgraph_(jsgraph),
        count_(jsgraph->graph()->NodeCount()),
        info_(zone->NewArray<NodeInfo>(count_)),
        nodes_(zone),
        replacements_(zone),
        contains_js_nodes_(false),
        phase_(PROPAGATE),
        changer_(changer),
        queue_(zone) {
    memset(info_, 0, sizeof(NodeInfo) * count_);
  }

References count_, and info_.

Member Function Documentation

BothInputsAre()

bool v8::internal::compiler::RepresentationSelector::BothInputsAre ( Node *  node, Type *  type  )

inline

Definition at line 161 of file simplified-lowering.cc.

                                             {
    DCHECK_EQ(2, node->InputCount());
    return NodeProperties::GetBounds(node->InputAt(0)).upper->Is(type) &&
           NodeProperties::GetBounds(node->InputAt(1)).upper->Is(type);
  }

References DCHECK_EQ, v8::internal::compiler::NodeProperties::GetBounds(), and v8::internal::BoundsImpl< Config >::upper.

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

DeferReplacement()

void v8::internal::compiler::RepresentationSelector::DeferReplacement ( Node *  node, Node *  replacement  )

inline

Definition at line 738 of file simplified-lowering.cc.

                                                       {
    if (replacement->id() < count_) {
      // Replace with a previously existing node eagerly.
      node->ReplaceUses(replacement);
    } else {
      // Otherwise, we are replacing a node with a representation change.
      // Such a substitution must be done after all lowering is done, because
      // new nodes do not have {NodeInfo} entries, and that would confuse
      // the representation change insertion for uses of it.
      replacements_.push_back(node);
      replacements_.push_back(replacement);
    }
    // TODO(titzer) node->RemoveAllInputs();  // Node is now dead.
  }

References count_, and replacements_.

Referenced by VisitNode().

Here is the caller graph for this function:

Enqueue() [1/2]

void v8::internal::compiler::RepresentationSelector::Enqueue ( Node *  node, MachineType  use  )

inline

Definition at line 148 of file simplified-lowering.cc.

                                            {
    Enqueue(node, static_cast<MachineTypeUnion>(use));
  }

References Enqueue(), and use().

Here is the call graph for this function:

Enqueue() [2/2]

void v8::internal::compiler::RepresentationSelector::Enqueue ( Node *  node, MachineTypeUnion  use = 0  )

inline

Definition at line 116 of file simplified-lowering.cc.

                                                     {
    if (phase_ != PROPAGATE) return;
    NodeInfo* info = GetInfo(node);
    if (!info->visited) {
      // First visit of this node.
      info->visited = true;
      info->queued = true;
      nodes_.push_back(node);
      queue_.push(node);
      TRACE(("  initial: "));
      info->use |= use;
      PrintUseInfo(node);
      return;
    }
    TRACE(("   queue?: "));
    PrintUseInfo(node);
    if ((info->use & use) != use) {
      // New usage information for the node is available.
      if (!info->queued) {
        queue_.push(node);
        info->queued = true;
        TRACE(("   added: "));
      } else {
        TRACE((" inqueue: "));
      }
      info->use |= use;
      PrintUseInfo(node);
    }
  }

References GetInfo(), nodes_, phase_, PrintUseInfo(), v8::internal::compiler::PROPAGATE, queue_, v8::internal::compiler::RepresentationSelector::NodeInfo::queued, TRACE, v8::internal::compiler::RepresentationSelector::NodeInfo::use, use(), and v8::internal::compiler::RepresentationSelector::NodeInfo::visited.

Referenced by Enqueue(), ProcessInput(), ProcessRemainingInputs(), Run(), VisitInputs(), and VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

Float64Op()

const Operator* v8::internal::compiler::RepresentationSelector::Float64Op ( Node *  node )

inline

Definition at line 350 of file simplified-lowering.cc.

                                        {
    return changer_->Float64OperatorFor(node->opcode());
  }

References changer_, and v8::internal::compiler::RepresentationChanger::Float64OperatorFor().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

GetInfo()

NodeInfo* v8::internal::compiler::RepresentationSelector::GetInfo ( Node *  node )

inlineprivate

Definition at line 777 of file simplified-lowering.cc.

                                {
    DCHECK(node->id() >= 0);
    DCHECK(node->id() < count_);
    return &info_[node->id()];
  }

References count_, DCHECK, and info_.

Referenced by Enqueue(), GetUseInfo(), ProcessInput(), Run(), SetOutput(), and VisitNode().

Here is the caller graph for this function:

GetUseInfo()

MachineTypeUnion v8::internal::compiler::RepresentationSelector::GetUseInfo ( Node *  node )

inlineprivate

Definition at line 783 of file simplified-lowering.cc.

{ return GetInfo(node)->use; }

References GetInfo(), and v8::internal::compiler::RepresentationSelector::NodeInfo::use.

Referenced by PrintUseInfo(), Run(), and VisitPhi().

Here is the call graph for this function:

Here is the caller graph for this function:

Int32Op()

const Operator* v8::internal::compiler::RepresentationSelector::Int32Op ( Node *  node )

inline

Definition at line 342 of file simplified-lowering.cc.

                                      {
    return changer_->Int32OperatorFor(node->opcode());
  }

References changer_, and v8::internal::compiler::RepresentationChanger::Int32OperatorFor().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

lower()

bool v8::internal::compiler::RepresentationSelector::lower ( )

inline

Definition at line 146 of file simplified-lowering.cc.

{ return phase_ == LOWER; }

References v8::internal::compiler::LOWER, and phase_.

Referenced by VisitNode(), and VisitPhi().

Here is the caller graph for this function:

PrintInfo()

void v8::internal::compiler::RepresentationSelector::PrintInfo ( MachineTypeUnion  info )

inline

Definition at line 759 of file simplified-lowering.cc.

                                        {
    if (FLAG_trace_representation) {
      OFStream os(stdout);
      os << static_cast<MachineType>(info);
    }
  }

Referenced by PrintUseInfo(), ProcessInput(), and Run().

Here is the caller graph for this function:

PrintUseInfo()

void v8::internal::compiler::RepresentationSelector::PrintUseInfo ( Node *  node )

inline

Definition at line 753 of file simplified-lowering.cc.

                                {
    TRACE(("#%d:%-20s ", node->id(), node->op()->mnemonic()));
    PrintInfo(GetUseInfo(node));
    TRACE(("\n"));
  }

References GetUseInfo(), PrintInfo(), and TRACE.

Referenced by Enqueue().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessInput()

void v8::internal::compiler::RepresentationSelector::ProcessInput ( Node *  node, int  index, MachineTypeUnion  use  )

inline

Definition at line 167 of file simplified-lowering.cc.

                                                                 {
    Node* input = node->InputAt(index);
    if (phase_ == PROPAGATE) {
      // In the propagate phase, propagate the usage information backward.
      Enqueue(input, use);
    } else {
      // In the change phase, insert a change before the use if necessary.
      if ((use & kRepMask) == 0) return;  // No input requirement on the use.
      MachineTypeUnion output = GetInfo(input)->output;
      if ((output & kRepMask & use) == 0) {
        // Output representation doesn't match usage.
        TRACE(("  change: #%d:%s(@%d #%d:%s) ", node->id(),
               node->op()->mnemonic(), index, input->id(),
               input->op()->mnemonic()));
        TRACE((" from "));
        PrintInfo(output);
        TRACE((" to "));
        PrintInfo(use);
        TRACE(("\n"));
        Node* n = changer_->GetRepresentationFor(input, output, use);
        node->ReplaceInput(index, n);
      }
    }
  }

References changer_, Enqueue(), GetInfo(), v8::internal::compiler::RepresentationChanger::GetRepresentationFor(), v8::internal::compiler::kRepMask, v8::internal::compiler::RepresentationSelector::NodeInfo::output, phase_, PrintInfo(), v8::internal::compiler::PROPAGATE, TRACE, and use().

Referenced by VisitBinop(), VisitInputs(), VisitNode(), VisitPhi(), and VisitUnop().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessRemainingInputs()

void v8::internal::compiler::RepresentationSelector::ProcessRemainingInputs ( Node *  node, int  index  )

inline

Definition at line 192 of file simplified-lowering.cc.

                                                     {
    DCHECK_GE(index, NodeProperties::PastValueIndex(node));
    DCHECK_GE(index, NodeProperties::PastContextIndex(node));
    for (int i = std::max(index, NodeProperties::FirstEffectIndex(node));
         i < NodeProperties::PastEffectIndex(node); ++i) {
      Enqueue(node->InputAt(i));  // Effect inputs: just visit
    }
    for (int i = std::max(index, NodeProperties::FirstControlIndex(node));
         i < NodeProperties::PastControlIndex(node); ++i) {
      Enqueue(node->InputAt(i));  // Control inputs: just visit
    }
  }

References DCHECK_GE, Enqueue(), v8::internal::compiler::NodeProperties::FirstControlIndex(), v8::internal::compiler::NodeProperties::FirstEffectIndex(), v8::internal::compiler::NodeProperties::PastContextIndex(), v8::internal::compiler::NodeProperties::PastControlIndex(), v8::internal::compiler::NodeProperties::PastEffectIndex(), and v8::internal::compiler::NodeProperties::PastValueIndex().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

Run()

void v8::internal::compiler::RepresentationSelector::Run ( SimplifiedLowering *  lowering )

inline

Definition at line 76 of file simplified-lowering.cc.

                                         {
    // Run propagation phase to a fixpoint.
    TRACE(("--{Propagation phase}--\n"));
    phase_ = PROPAGATE;
    Enqueue(jsgraph_->graph()->end());
    // Process nodes from the queue until it is empty.
    while (!queue_.empty()) {
      Node* node = queue_.front();
      NodeInfo* info = GetInfo(node);
      queue_.pop();
      info->queued = false;
      TRACE((" visit #%d: %s\n", node->id(), node->op()->mnemonic()));
      VisitNode(node, info->use, NULL);
      TRACE(("  ==> output "));
      PrintInfo(info->output);
      TRACE(("\n"));
    }
 
    // Run lowering and change insertion phase.
    TRACE(("--{Simplified lowering phase}--\n"));
    phase_ = LOWER;
    // Process nodes from the collected {nodes_} vector.
    for (NodeVector::iterator i = nodes_.begin(); i != nodes_.end(); ++i) {
      Node* node = *i;
      TRACE((" visit #%d: %s\n", node->id(), node->op()->mnemonic()));
      // Reuse {VisitNode()} so the representation rules are in one place.
      VisitNode(node, GetUseInfo(node), lowering);
    }
 
    // Perform the final replacements.
    for (NodeVector::iterator i = replacements_.begin();
         i != replacements_.end(); ++i) {
      Node* node = *i;
      Node* replacement = *(++i);
      node->ReplaceUses(replacement);
    }
  }

References v8::internal::compiler::GenericGraph< V >::end(), Enqueue(), GetInfo(), GetUseInfo(), v8::internal::compiler::JSGraph::graph(), jsgraph_, v8::internal::compiler::LOWER, nodes_, NULL, v8::internal::compiler::RepresentationSelector::NodeInfo::output, phase_, PrintInfo(), v8::internal::compiler::PROPAGATE, queue_, v8::internal::compiler::RepresentationSelector::NodeInfo::queued, replacements_, TRACE, v8::internal::compiler::RepresentationSelector::NodeInfo::use, and VisitNode().

Referenced by v8::internal::compiler::SimplifiedLowering::LowerAllNodes().

Here is the call graph for this function:

Here is the caller graph for this function:

SetOutput()

void v8::internal::compiler::RepresentationSelector::SetOutput ( Node *  node, MachineTypeUnion  output  )

inline

Definition at line 152 of file simplified-lowering.cc.

                                                      {
    // Every node should have at most one output representation. Note that
    // phis can have 0, if they have not been used in a representation-inducing
    // instruction.
    DCHECK((output & kRepMask) == 0 ||
           base::bits::IsPowerOfTwo32(output & kRepMask));
    GetInfo(node)->output = output;
  }

References DCHECK, GetInfo(), v8::base::bits::IsPowerOfTwo32(), v8::internal::compiler::kRepMask, and v8::internal::compiler::RepresentationSelector::NodeInfo::output.

Referenced by VisitBinop(), VisitInputs(), VisitLeaf(), VisitNode(), VisitPhi(), and VisitUnop().

Here is the call graph for this function:

Here is the caller graph for this function:

Uint32Op()

const Operator* v8::internal::compiler::RepresentationSelector::Uint32Op ( Node *  node )

inline

Definition at line 346 of file simplified-lowering.cc.

                                       {
    return changer_->Uint32OperatorFor(node->opcode());
  }

References changer_, and v8::internal::compiler::RepresentationChanger::Uint32OperatorFor().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitBinop()

void v8::internal::compiler::RepresentationSelector::VisitBinop ( Node *  node, MachineTypeUnion  input_use, MachineTypeUnion  output  )

inline

Definition at line 230 of file simplified-lowering.cc.

                                           {
    DCHECK_EQ(2, node->InputCount());
    ProcessInput(node, 0, input_use);
    ProcessInput(node, 1, input_use);
    SetOutput(node, output);
  }

References DCHECK_EQ, ProcessInput(), and SetOutput().

Referenced by VisitFloat64Binop(), VisitFloat64Cmp(), VisitInt32Binop(), VisitInt32Cmp(), VisitInt64Binop(), VisitInt64Cmp(), VisitNode(), VisitUint32Binop(), VisitUint32Cmp(), VisitUint64Binop(), and VisitUint64Cmp().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitFloat64Binop()

void v8::internal::compiler::RepresentationSelector::VisitFloat64Binop ( Node *  node )

inline

Definition at line 253 of file simplified-lowering.cc.

                                     {
    VisitBinop(node, kMachFloat64, kMachFloat64);
  }

References v8::internal::compiler::kMachFloat64, and VisitBinop().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitFloat64Cmp()

void v8::internal::compiler::RepresentationSelector::VisitFloat64Cmp ( Node *  node )

inline

Definition at line 264 of file simplified-lowering.cc.

{ VisitBinop(node, kMachFloat64, kRepBit); }

References v8::internal::compiler::kMachFloat64, v8::internal::compiler::kRepBit, and VisitBinop().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitInputs()

void v8::internal::compiler::RepresentationSelector::VisitInputs ( Node *  node )

inline

Definition at line 208 of file simplified-lowering.cc.

                               {
    InputIter i = node->inputs().begin();
    for (int j = OperatorProperties::GetValueInputCount(node->op()); j > 0;
         ++i, j--) {
      ProcessInput(node, i.index(), kMachAnyTagged);  // Value inputs
    }
    for (int j = OperatorProperties::GetContextInputCount(node->op()); j > 0;
         ++i, j--) {
      ProcessInput(node, i.index(), kMachAnyTagged);  // Context inputs
    }
    for (int j = OperatorProperties::GetEffectInputCount(node->op()); j > 0;
         ++i, j--) {
      Enqueue(*i);  // Effect inputs: just visit
    }
    for (int j = OperatorProperties::GetControlInputCount(node->op()); j > 0;
         ++i, j--) {
      Enqueue(*i);  // Control inputs: just visit
    }
    SetOutput(node, kMachAnyTagged);
  }

References Enqueue(), v8::internal::compiler::OperatorProperties::GetContextInputCount(), v8::internal::compiler::OperatorProperties::GetControlInputCount(), v8::internal::compiler::OperatorProperties::GetEffectInputCount(), v8::internal::compiler::OperatorProperties::GetValueInputCount(), v8::internal::compiler::kMachAnyTagged, ProcessInput(), and SetOutput().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitInt32Binop()

void v8::internal::compiler::RepresentationSelector::VisitInt32Binop ( Node *  node )

inline

Definition at line 256 of file simplified-lowering.cc.

{ VisitBinop(node, kMachInt32, kMachInt32); }

References v8::internal::compiler::kMachInt32, and VisitBinop().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitInt32Cmp()

void v8::internal::compiler::RepresentationSelector::VisitInt32Cmp ( Node *  node )

inline

Definition at line 265 of file simplified-lowering.cc.

{ VisitBinop(node, kMachInt32, kRepBit); }

References v8::internal::compiler::kMachInt32, v8::internal::compiler::kRepBit, and VisitBinop().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitInt64Binop()

void v8::internal::compiler::RepresentationSelector::VisitInt64Binop ( Node *  node )

inline

Definition at line 260 of file simplified-lowering.cc.

{ VisitBinop(node, kMachInt64, kMachInt64); }

References v8::internal::compiler::kMachInt64, and VisitBinop().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitInt64Cmp()

void v8::internal::compiler::RepresentationSelector::VisitInt64Cmp ( Node *  node )

inline

Definition at line 267 of file simplified-lowering.cc.

{ VisitBinop(node, kMachInt64, kRepBit); }

References v8::internal::compiler::kMachInt64, v8::internal::compiler::kRepBit, and VisitBinop().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitLeaf()

void v8::internal::compiler::RepresentationSelector::VisitLeaf ( Node *  node, MachineTypeUnion  output  )

inline

Definition at line 247 of file simplified-lowering.cc.

                                                      {
    DCHECK_EQ(0, node->InputCount());
    SetOutput(node, output);
  }

References DCHECK_EQ, and SetOutput().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitNode()

void v8::internal::compiler::RepresentationSelector::VisitNode ( Node *  node, MachineTypeUnion  use, SimplifiedLowering *  lowering  )

inline

Definition at line 356 of file simplified-lowering.cc.

                                               {
    switch (node->opcode()) {
      //------------------------------------------------------------------
      // Common operators.
      //------------------------------------------------------------------
      case IrOpcode::kStart:
      case IrOpcode::kDead:
        return VisitLeaf(node, 0);
      case IrOpcode::kParameter: {
        // TODO(titzer): use representation from linkage.
        Type* upper = NodeProperties::GetBounds(node).upper;
        ProcessInput(node, 0, 0);
        SetOutput(node, kRepTagged | changer_->TypeFromUpperBound(upper));
        return;
      }
      case IrOpcode::kInt32Constant:
        return VisitLeaf(node, kRepWord32);
      case IrOpcode::kInt64Constant:
        return VisitLeaf(node, kRepWord64);
      case IrOpcode::kFloat64Constant:
        return VisitLeaf(node, kRepFloat64);
      case IrOpcode::kExternalConstant:
        return VisitLeaf(node, kMachPtr);
      case IrOpcode::kNumberConstant:
        return VisitLeaf(node, kRepTagged);
      case IrOpcode::kHeapConstant:
        return VisitLeaf(node, kRepTagged);
 
      case IrOpcode::kEnd:
      case IrOpcode::kIfTrue:
      case IrOpcode::kIfFalse:
      case IrOpcode::kReturn:
      case IrOpcode::kMerge:
      case IrOpcode::kThrow:
        return VisitInputs(node);  // default visit for all node inputs.
 
      case IrOpcode::kBranch:
        ProcessInput(node, 0, kRepBit);
        Enqueue(NodeProperties::GetControlInput(node, 0));
        break;
      case IrOpcode::kPhi:
        return VisitPhi(node, use, lowering);
 
//------------------------------------------------------------------
// JavaScript operators.
//------------------------------------------------------------------
// For now, we assume that all JS operators were too complex to lower
// to Simplified and that they will always require tagged value inputs
// and produce tagged value outputs.
// TODO(turbofan): it might be possible to lower some JSOperators here,
// but that responsibility really lies in the typed lowering phase.
#define DEFINE_JS_CASE(x) case IrOpcode::k##x:
        JS_OP_LIST(DEFINE_JS_CASE)
#undef DEFINE_JS_CASE
        contains_js_nodes_ = true;
        VisitInputs(node);
        return SetOutput(node, kRepTagged);
 
      //------------------------------------------------------------------
      // Simplified operators.
      //------------------------------------------------------------------
      case IrOpcode::kBooleanNot: {
        if (lower()) {
          MachineTypeUnion input = GetInfo(node->InputAt(0))->output;
          if (input & kRepBit) {
            // BooleanNot(x: kRepBit) => WordEqual(x, #0)
            node->set_op(lowering->machine()->WordEqual());
            node->AppendInput(jsgraph_->zone(), jsgraph_->Int32Constant(0));
          } else {
            // BooleanNot(x: kRepTagged) => WordEqual(x, #false)
            node->set_op(lowering->machine()->WordEqual());
            node->AppendInput(jsgraph_->zone(), jsgraph_->FalseConstant());
          }
        } else {
          // No input representation requirement; adapt during lowering.
          ProcessInput(node, 0, kTypeBool);
          SetOutput(node, kRepBit);
        }
        break;
      }
      case IrOpcode::kBooleanToNumber: {
        if (lower()) {
          MachineTypeUnion input = GetInfo(node->InputAt(0))->output;
          if (input & kRepBit) {
            // BooleanToNumber(x: kRepBit) => x
            DeferReplacement(node, node->InputAt(0));
          } else {
            // BooleanToNumber(x: kRepTagged) => WordEqual(x, #true)
            node->set_op(lowering->machine()->WordEqual());
            node->AppendInput(jsgraph_->zone(), jsgraph_->TrueConstant());
          }
        } else {
          // No input representation requirement; adapt during lowering.
          ProcessInput(node, 0, kTypeBool);
          SetOutput(node, kMachInt32);
        }
        break;
      }
      case IrOpcode::kNumberEqual:
      case IrOpcode::kNumberLessThan:
      case IrOpcode::kNumberLessThanOrEqual: {
        // Number comparisons reduce to integer comparisons for integer inputs.
        if (BothInputsAre(node, Type::Signed32())) {
          // => signed Int32Cmp
          VisitInt32Cmp(node);
          if (lower()) node->set_op(Int32Op(node));
        } else if (BothInputsAre(node, Type::Unsigned32())) {
          // => unsigned Int32Cmp
          VisitUint32Cmp(node);
          if (lower()) node->set_op(Uint32Op(node));
        } else {
          // => Float64Cmp
          VisitFloat64Cmp(node);
          if (lower()) node->set_op(Float64Op(node));
        }
        break;
      }
      case IrOpcode::kNumberAdd:
      case IrOpcode::kNumberSubtract: {
        // Add and subtract reduce to Int32Add/Sub if the inputs
        // are already integers and all uses are truncating.
        if (BothInputsAre(node, Type::Signed32()) &&
            (use & (kTypeUint32 | kTypeNumber | kTypeAny)) == 0) {
          // => signed Int32Add/Sub
          VisitInt32Binop(node);
          if (lower()) node->set_op(Int32Op(node));
        } else if (BothInputsAre(node, Type::Unsigned32()) &&
                   (use & (kTypeInt32 | kTypeNumber | kTypeAny)) == 0) {
          // => unsigned Int32Add/Sub
          VisitUint32Binop(node);
          if (lower()) node->set_op(Uint32Op(node));
        } else {
          // => Float64Add/Sub
          VisitFloat64Binop(node);
          if (lower()) node->set_op(Float64Op(node));
        }
        break;
      }
      case IrOpcode::kNumberMultiply:
      case IrOpcode::kNumberDivide:
      case IrOpcode::kNumberModulus: {
        // Float64Mul/Div/Mod
        VisitFloat64Binop(node);
        if (lower()) node->set_op(Float64Op(node));
        break;
      }
      case IrOpcode::kNumberToInt32: {
        MachineTypeUnion use_rep = use & kRepMask;
        if (lower()) {
          MachineTypeUnion in = GetInfo(node->InputAt(0))->output;
          if ((in & kTypeMask) == kTypeInt32 || (in & kRepMask) == kRepWord32) {
            // If the input has type int32, or is already a word32, just change
            // representation if necessary.
            VisitUnop(node, kTypeInt32 | use_rep, kTypeInt32 | use_rep);
            DeferReplacement(node, node->InputAt(0));
          } else {
            // Require the input in float64 format and perform truncation.
            // TODO(turbofan): avoid a truncation with a smi check.
            VisitUnop(node, kTypeInt32 | kRepFloat64, kTypeInt32 | kRepWord32);
            node->set_op(lowering->machine()->TruncateFloat64ToInt32());
          }
        } else {
          // Propagate a type to the input, but pass through representation.
          VisitUnop(node, kTypeInt32, kTypeInt32 | use_rep);
        }
        break;
      }
      case IrOpcode::kNumberToUint32: {
        MachineTypeUnion use_rep = use & kRepMask;
        if (lower()) {
          MachineTypeUnion in = GetInfo(node->InputAt(0))->output;
          if ((in & kTypeMask) == kTypeUint32 ||
              (in & kRepMask) == kRepWord32) {
            // The input has type int32, just change representation.
            VisitUnop(node, kTypeUint32 | use_rep, kTypeUint32 | use_rep);
            DeferReplacement(node, node->InputAt(0));
          } else {
            // Require the input in float64 format to perform truncation.
            // TODO(turbofan): avoid the truncation with a smi check.
            VisitUnop(node, kTypeUint32 | kRepFloat64,
                      kTypeUint32 | kRepWord32);
            node->set_op(lowering->machine()->TruncateFloat64ToInt32());
          }
        } else {
          // Propagate a type to the input, but pass through representation.
          VisitUnop(node, kTypeUint32, kTypeUint32 | use_rep);
        }
        break;
      }
      case IrOpcode::kReferenceEqual: {
        VisitBinop(node, kMachAnyTagged, kRepBit);
        if (lower()) node->set_op(lowering->machine()->WordEqual());
        break;
      }
      case IrOpcode::kStringEqual: {
        VisitBinop(node, kMachAnyTagged, kRepBit);
        if (lower()) lowering->DoStringEqual(node);
        break;
      }
      case IrOpcode::kStringLessThan: {
        VisitBinop(node, kMachAnyTagged, kRepBit);
        if (lower()) lowering->DoStringLessThan(node);
        break;
      }
      case IrOpcode::kStringLessThanOrEqual: {
        VisitBinop(node, kMachAnyTagged, kRepBit);
        if (lower()) lowering->DoStringLessThanOrEqual(node);
        break;
      }
      case IrOpcode::kStringAdd: {
        VisitBinop(node, kMachAnyTagged, kMachAnyTagged);
        if (lower()) lowering->DoStringAdd(node);
        break;
      }
      case IrOpcode::kLoadField: {
        FieldAccess access = FieldAccessOf(node->op());
        ProcessInput(node, 0, changer_->TypeForBasePointer(access));
        ProcessRemainingInputs(node, 1);
        SetOutput(node, access.machine_type);
        if (lower()) lowering->DoLoadField(node);
        break;
      }
      case IrOpcode::kStoreField: {
        FieldAccess access = FieldAccessOf(node->op());
        ProcessInput(node, 0, changer_->TypeForBasePointer(access));
        ProcessInput(node, 1, access.machine_type);
        ProcessRemainingInputs(node, 2);
        SetOutput(node, 0);
        if (lower()) lowering->DoStoreField(node);
        break;
      }
      case IrOpcode::kLoadElement: {
        ElementAccess access = ElementAccessOf(node->op());
        ProcessInput(node, 0, changer_->TypeForBasePointer(access));
        ProcessInput(node, 1, kMachInt32);  // element index
        ProcessInput(node, 2, kMachInt32);  // length
        ProcessRemainingInputs(node, 3);
        SetOutput(node, access.machine_type);
        if (lower()) lowering->DoLoadElement(node);
        break;
      }
      case IrOpcode::kStoreElement: {
        ElementAccess access = ElementAccessOf(node->op());
        ProcessInput(node, 0, changer_->TypeForBasePointer(access));
        ProcessInput(node, 1, kMachInt32);  // element index
        ProcessInput(node, 2, kMachInt32);  // length
        ProcessInput(node, 3, access.machine_type);
        ProcessRemainingInputs(node, 4);
        SetOutput(node, 0);
        if (lower()) lowering->DoStoreElement(node);
        break;
      }
 
      //------------------------------------------------------------------
      // Machine-level operators.
      //------------------------------------------------------------------
      case IrOpcode::kLoad: {
        // TODO(titzer): machine loads/stores need to know BaseTaggedness!?
        MachineType tBase = kRepTagged;
        LoadRepresentation rep = OpParameter<LoadRepresentation>(node);
        ProcessInput(node, 0, tBase);   // pointer or object
        ProcessInput(node, 1, kMachInt32);  // index
        ProcessRemainingInputs(node, 2);
        SetOutput(node, rep);
        break;
      }
      case IrOpcode::kStore: {
        // TODO(titzer): machine loads/stores need to know BaseTaggedness!?
        MachineType tBase = kRepTagged;
        StoreRepresentation rep = OpParameter<StoreRepresentation>(node);
        ProcessInput(node, 0, tBase);   // pointer or object
        ProcessInput(node, 1, kMachInt32);  // index
        ProcessInput(node, 2, rep.machine_type());
        ProcessRemainingInputs(node, 3);
        SetOutput(node, 0);
        break;
      }
      case IrOpcode::kWord32Shr:
        // We output unsigned int32 for shift right because JavaScript.
        return VisitBinop(node, kRepWord32, kRepWord32 | kTypeUint32);
      case IrOpcode::kWord32And:
      case IrOpcode::kWord32Or:
      case IrOpcode::kWord32Xor:
      case IrOpcode::kWord32Shl:
      case IrOpcode::kWord32Sar:
        // We use signed int32 as the output type for these word32 operations,
        // though the machine bits are the same for either signed or unsigned,
        // because JavaScript considers the result from these operations signed.
        return VisitBinop(node, kRepWord32, kRepWord32 | kTypeInt32);
      case IrOpcode::kWord32Equal:
        return VisitBinop(node, kRepWord32, kRepBit);
 
      case IrOpcode::kInt32Add:
      case IrOpcode::kInt32Sub:
      case IrOpcode::kInt32Mul:
      case IrOpcode::kInt32Div:
      case IrOpcode::kInt32Mod:
        return VisitInt32Binop(node);
      case IrOpcode::kInt32UDiv:
      case IrOpcode::kInt32UMod:
        return VisitUint32Binop(node);
      case IrOpcode::kInt32LessThan:
      case IrOpcode::kInt32LessThanOrEqual:
        return VisitInt32Cmp(node);
 
      case IrOpcode::kUint32LessThan:
      case IrOpcode::kUint32LessThanOrEqual:
        return VisitUint32Cmp(node);
 
      case IrOpcode::kInt64Add:
      case IrOpcode::kInt64Sub:
      case IrOpcode::kInt64Mul:
      case IrOpcode::kInt64Div:
      case IrOpcode::kInt64Mod:
        return VisitInt64Binop(node);
      case IrOpcode::kInt64LessThan:
      case IrOpcode::kInt64LessThanOrEqual:
        return VisitInt64Cmp(node);
 
      case IrOpcode::kInt64UDiv:
      case IrOpcode::kInt64UMod:
        return VisitUint64Binop(node);
 
      case IrOpcode::kWord64And:
      case IrOpcode::kWord64Or:
      case IrOpcode::kWord64Xor:
      case IrOpcode::kWord64Shl:
      case IrOpcode::kWord64Shr:
      case IrOpcode::kWord64Sar:
        return VisitBinop(node, kRepWord64, kRepWord64);
      case IrOpcode::kWord64Equal:
        return VisitBinop(node, kRepWord64, kRepBit);
 
      case IrOpcode::kChangeInt32ToInt64:
        return VisitUnop(node, kTypeInt32 | kRepWord32,
                         kTypeInt32 | kRepWord64);
      case IrOpcode::kChangeUint32ToUint64:
        return VisitUnop(node, kTypeUint32 | kRepWord32,
                         kTypeUint32 | kRepWord64);
      case IrOpcode::kTruncateFloat64ToFloat32:
        return VisitUnop(node, kTypeNumber | kRepFloat64,
                         kTypeNumber | kRepFloat32);
      case IrOpcode::kTruncateInt64ToInt32:
        // TODO(titzer): Is kTypeInt32 correct here?
        return VisitUnop(node, kTypeInt32 | kRepWord64,
                         kTypeInt32 | kRepWord32);
 
      case IrOpcode::kChangeFloat32ToFloat64:
        return VisitUnop(node, kTypeNumber | kRepFloat32,
                         kTypeNumber | kRepFloat64);
      case IrOpcode::kChangeInt32ToFloat64:
        return VisitUnop(node, kTypeInt32 | kRepWord32,
                         kTypeInt32 | kRepFloat64);
      case IrOpcode::kChangeUint32ToFloat64:
        return VisitUnop(node, kTypeUint32 | kRepWord32,
                         kTypeUint32 | kRepFloat64);
      case IrOpcode::kChangeFloat64ToInt32:
        return VisitUnop(node, kTypeInt32 | kRepFloat64,
                         kTypeInt32 | kRepWord32);
      case IrOpcode::kChangeFloat64ToUint32:
        return VisitUnop(node, kTypeUint32 | kRepFloat64,
                         kTypeUint32 | kRepWord32);
 
      case IrOpcode::kFloat64Add:
      case IrOpcode::kFloat64Sub:
      case IrOpcode::kFloat64Mul:
      case IrOpcode::kFloat64Div:
      case IrOpcode::kFloat64Mod:
        return VisitFloat64Binop(node);
      case IrOpcode::kFloat64Sqrt:
        return VisitUnop(node, kMachFloat64, kMachFloat64);
      case IrOpcode::kFloat64Equal:
      case IrOpcode::kFloat64LessThan:
      case IrOpcode::kFloat64LessThanOrEqual:
        return VisitFloat64Cmp(node);
      default:
        VisitInputs(node);
        break;
    }
  }

References BothInputsAre(), changer_, contains_js_nodes_, DeferReplacement(), DEFINE_JS_CASE, v8::internal::compiler::SimplifiedLowering::DoLoadElement(), v8::internal::compiler::SimplifiedLowering::DoLoadField(), v8::internal::compiler::SimplifiedLowering::DoStoreElement(), v8::internal::compiler::SimplifiedLowering::DoStoreField(), v8::internal::compiler::SimplifiedLowering::DoStringAdd(), v8::internal::compiler::SimplifiedLowering::DoStringEqual(), v8::internal::compiler::SimplifiedLowering::DoStringLessThan(), v8::internal::compiler::SimplifiedLowering::DoStringLessThanOrEqual(), v8::internal::compiler::ElementAccessOf(), Enqueue(), v8::internal::compiler::JSGraph::FalseConstant(), v8::internal::compiler::FieldAccessOf(), Float64Op(), v8::internal::compiler::NodeProperties::GetBounds(), v8::internal::compiler::NodeProperties::GetControlInput(), GetInfo(), v8::internal::compiler::JSGraph::Int32Constant(), Int32Op(), JS_OP_LIST, jsgraph_, v8::internal::compiler::kMachAnyTagged, v8::internal::compiler::kMachFloat64, v8::internal::compiler::kMachInt32, v8::internal::compiler::kMachPtr, v8::internal::compiler::kRepBit, v8::internal::compiler::kRepFloat32, v8::internal::compiler::kRepFloat64, v8::internal::compiler::kRepMask, v8::internal::compiler::kRepTagged, v8::internal::compiler::kRepWord32, v8::internal::compiler::kRepWord64, v8::internal::compiler::kTypeAny, v8::internal::compiler::kTypeBool, v8::internal::compiler::kTypeInt32, v8::internal::compiler::kTypeMask, v8::internal::compiler::kTypeNumber, v8::internal::compiler::kTypeUint32, lower(), v8::internal::compiler::SimplifiedLowering::machine(), v8::internal::compiler::FieldAccess::machine_type, v8::internal::compiler::ElementAccess::machine_type, v8::internal::compiler::RepresentationSelector::NodeInfo::output, ProcessInput(), ProcessRemainingInputs(), SetOutput(), v8::internal::compiler::JSGraph::TrueConstant(), v8::internal::compiler::RepresentationChanger::TypeForBasePointer(), v8::internal::compiler::RepresentationChanger::TypeFromUpperBound(), Uint32Op(), v8::internal::BoundsImpl< Config >::upper, use(), VisitBinop(), VisitFloat64Binop(), VisitFloat64Cmp(), VisitInputs(), VisitInt32Binop(), VisitInt32Cmp(), VisitInt64Binop(), VisitInt64Cmp(), VisitLeaf(), VisitPhi(), VisitUint32Binop(), VisitUint32Cmp(), VisitUint64Binop(), VisitUnop(), and v8::internal::compiler::JSGraph::zone().

Referenced by Run().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitPhi()

void v8::internal::compiler::RepresentationSelector::VisitPhi ( Node *  node, MachineTypeUnion  use, SimplifiedLowering *  lowering  )

inline

Definition at line 271 of file simplified-lowering.cc.

                                              {
    // First, propagate the usage information to inputs of the phi.
    if (!lower()) {
      int values = OperatorProperties::GetValueInputCount(node->op());
      // Propagate {use} of the phi to value inputs, and 0 to control.
      Node::Inputs inputs = node->inputs();
      for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
           ++iter, --values) {
        // TODO(titzer): it'd be nice to have distinguished edge kinds here.
        ProcessInput(node, iter.index(), values > 0 ? use : 0);
      }
    }
    // Phis adapt to whatever output representation their uses demand,
    // pushing representation changes to their inputs.
    MachineTypeUnion use_rep = GetUseInfo(node) & kRepMask;
    MachineTypeUnion use_type = GetUseInfo(node) & kTypeMask;
    MachineTypeUnion rep = 0;
    if (use_rep & kRepTagged) {
      rep = kRepTagged;  // Tagged overrides everything.
    } else if (use_rep & kRepFloat32) {
      rep = kRepFloat32;
    } else if (use_rep & kRepFloat64) {
      rep = kRepFloat64;
    } else if (use_rep & kRepWord64) {
      rep = kRepWord64;
    } else if (use_rep & kRepWord32) {
      rep = kRepWord32;
    } else if (use_rep & kRepBit) {
      rep = kRepBit;
    } else {
      // There was no representation associated with any of the uses.
      // TODO(titzer): Select the best rep using phi's type, not the usage type?
      if (use_type & kTypeAny) {
        rep = kRepTagged;
      } else if (use_type & kTypeNumber) {
        rep = kRepFloat64;
      } else if (use_type & kTypeInt64 || use_type & kTypeUint64) {
        rep = kRepWord64;
      } else if (use_type & kTypeInt32 || use_type & kTypeUint32) {
        rep = kRepWord32;
      } else if (use_type & kTypeBool) {
        rep = kRepBit;
      } else {
        UNREACHABLE();  // should have at least a usage type!
      }
    }
    // Preserve the usage type, but set the representation.
    Type* upper = NodeProperties::GetBounds(node).upper;
    MachineTypeUnion output_type = rep | changer_->TypeFromUpperBound(upper);
    SetOutput(node, output_type);
 
    if (lower()) {
      int values = OperatorProperties::GetValueInputCount(node->op());
 
      // Update the phi operator.
      MachineType type = static_cast<MachineType>(output_type);
      if (type != OpParameter<MachineType>(node)) {
        node->set_op(lowering->common()->Phi(type, values));
      }
 
      // Convert inputs to the output representation of this phi.
      Node::Inputs inputs = node->inputs();
      for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
           ++iter, --values) {
        // TODO(titzer): it'd be nice to have distinguished edge kinds here.
        ProcessInput(node, iter.index(), values > 0 ? output_type : 0);
      }
    }
  }

References changer_, v8::internal::compiler::SimplifiedLowering::common(), v8::internal::compiler::NodeProperties::GetBounds(), GetUseInfo(), v8::internal::compiler::OperatorProperties::GetValueInputCount(), v8::internal::compiler::kRepBit, v8::internal::compiler::kRepFloat32, v8::internal::compiler::kRepFloat64, v8::internal::compiler::kRepMask, v8::internal::compiler::kRepTagged, v8::internal::compiler::kRepWord32, v8::internal::compiler::kRepWord64, v8::internal::compiler::kTypeAny, v8::internal::compiler::kTypeBool, v8::internal::compiler::kTypeInt32, v8::internal::compiler::kTypeInt64, v8::internal::compiler::kTypeMask, v8::internal::compiler::kTypeNumber, v8::internal::compiler::kTypeUint32, v8::internal::compiler::kTypeUint64, lower(), ProcessInput(), SetOutput(), v8::internal::compiler::RepresentationChanger::TypeFromUpperBound(), UNREACHABLE, v8::internal::BoundsImpl< Config >::upper, and use().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitUint32Binop()

void v8::internal::compiler::RepresentationSelector::VisitUint32Binop ( Node *  node )

inline

Definition at line 257 of file simplified-lowering.cc.

                                    {
    VisitBinop(node, kMachUint32, kMachUint32);
  }

References v8::internal::compiler::kMachUint32, and VisitBinop().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitUint32Cmp()

void v8::internal::compiler::RepresentationSelector::VisitUint32Cmp ( Node *  node )

inline

Definition at line 266 of file simplified-lowering.cc.

{ VisitBinop(node, kMachUint32, kRepBit); }

References v8::internal::compiler::kMachUint32, v8::internal::compiler::kRepBit, and VisitBinop().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitUint64Binop()

void v8::internal::compiler::RepresentationSelector::VisitUint64Binop ( Node *  node )

inline

Definition at line 261 of file simplified-lowering.cc.

                                    {
    VisitBinop(node, kMachUint64, kMachUint64);
  }

References v8::internal::compiler::kMachUint64, and VisitBinop().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitUint64Cmp()

void v8::internal::compiler::RepresentationSelector::VisitUint64Cmp ( Node *  node )

inline

Definition at line 268 of file simplified-lowering.cc.

{ VisitBinop(node, kMachUint64, kRepBit); }

References v8::internal::compiler::kMachUint64, v8::internal::compiler::kRepBit, and VisitBinop().

Here is the call graph for this function:

VisitUnop()

void v8::internal::compiler::RepresentationSelector::VisitUnop ( Node *  node, MachineTypeUnion  input_use, MachineTypeUnion  output  )

inline

Definition at line 239 of file simplified-lowering.cc.

                                          {
    DCHECK_EQ(1, node->InputCount());
    ProcessInput(node, 0, input_use);
    SetOutput(node, output);
  }

References DCHECK_EQ, ProcessInput(), and SetOutput().

Referenced by VisitNode().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

changer_

RepresentationChanger* v8::internal::compiler::RepresentationSelector::changer_

private

Definition at line 774 of file simplified-lowering.cc.

Referenced by Float64Op(), Int32Op(), ProcessInput(), Uint32Op(), VisitNode(), and VisitPhi().

contains_js_nodes_

bool v8::internal::compiler::RepresentationSelector::contains_js_nodes_

private

Definition at line 772 of file simplified-lowering.cc.

Referenced by VisitNode().

count_

int v8::internal::compiler::RepresentationSelector::count_

private

Definition at line 768 of file simplified-lowering.cc.

Referenced by DeferReplacement(), GetInfo(), and RepresentationSelector().

info_

NodeInfo* v8::internal::compiler::RepresentationSelector::info_

private

Definition at line 769 of file simplified-lowering.cc.

Referenced by GetInfo(), and RepresentationSelector().

jsgraph_

JSGraph* v8::internal::compiler::RepresentationSelector::jsgraph_

private

Definition at line 767 of file simplified-lowering.cc.

Referenced by Run(), and VisitNode().

nodes_

NodeVector v8::internal::compiler::RepresentationSelector::nodes_

private

Definition at line 770 of file simplified-lowering.cc.

Referenced by Enqueue(), and Run().

phase_

Phase v8::internal::compiler::RepresentationSelector::phase_

private

Definition at line 773 of file simplified-lowering.cc.

Referenced by Enqueue(), lower(), ProcessInput(), and Run().

queue_

ZoneQueue<Node*> v8::internal::compiler::RepresentationSelector::queue_

private

Definition at line 775 of file simplified-lowering.cc.

Referenced by Enqueue(), and Run().

replacements_

NodeVector v8::internal::compiler::RepresentationSelector::replacements_

private

Definition at line 771 of file simplified-lowering.cc.

Referenced by DeferReplacement(), and Run().

---

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

• /mnt/V8SourceCode/src/compiler/simplified-lowering.cc