v8::internal::compiler::Verifier::Visitor Class Reference

Inheritance diagram for v8::internal::compiler::Verifier::Visitor:

Collaboration diagram for v8::internal::compiler::Verifier::Visitor:

Public Member Functions
	Visitor (Zone *zone)
GenericGraphVisit::Control	Pre (Node *node)
Public Member Functions inherited from v8::internal::compiler::GenericGraphVisit::NullNodeVisitor< B, S >
Control	Pre (GenericNode< B, S > *node)
Control	Post (GenericNode< B, S > *node)
void	PreEdge (GenericNode< B, S > *from, int index, GenericNode< B, S > *to)
void	PostEdge (GenericNode< B, S > *from, int index, GenericNode< B, S > *to)

Public Attributes
bool	from_start
NodeSet	reached_from_start
NodeSet	reached_from_end

Detailed Description

Definition at line 46 of file verifier.cc.

Constructor & Destructor Documentation

Visitor()

v8::internal::compiler::Verifier::Visitor::Visitor ( Zone *  zone )

inlineexplicit

Definition at line 48 of file verifier.cc.

      : reached_from_start(NodeSet::key_compare(),
                           NodeSet::allocator_type(zone)),
        reached_from_end(NodeSet::key_compare(),
                         NodeSet::allocator_type(zone)) {}

Member Function Documentation

Pre()

GenericGraphVisit::Control v8::internal::compiler::Verifier::Visitor::Pre

(

Node *

node

)

Definition at line 63 of file verifier.cc.

                                                        {
  int value_count = OperatorProperties::GetValueInputCount(node->op());
  int context_count = OperatorProperties::GetContextInputCount(node->op());
  int frame_state_count =
      OperatorProperties::GetFrameStateInputCount(node->op());
  int effect_count = OperatorProperties::GetEffectInputCount(node->op());
  int control_count = OperatorProperties::GetControlInputCount(node->op());
 
  // Verify number of inputs matches up.
  int input_count = value_count + context_count + frame_state_count +
                    effect_count + control_count;
  CHECK_EQ(input_count, node->InputCount());
 
  // Verify that frame state has been inserted for the nodes that need it.
  if (OperatorProperties::HasFrameStateInput(node->op())) {
    Node* frame_state = NodeProperties::GetFrameStateInput(node);
    CHECK(frame_state->opcode() == IrOpcode::kFrameState ||
          // kFrameState uses undefined as a sentinel.
          (node->opcode() == IrOpcode::kFrameState &&
           frame_state->opcode() == IrOpcode::kHeapConstant));
    CHECK(IsDefUseChainLinkPresent(frame_state, node));
    CHECK(IsUseDefChainLinkPresent(frame_state, node));
  }
 
  // Verify all value inputs actually produce a value.
  for (int i = 0; i < value_count; ++i) {
    Node* value = NodeProperties::GetValueInput(node, i);
    CHECK(OperatorProperties::HasValueOutput(value->op()));
    CHECK(IsDefUseChainLinkPresent(value, node));
    CHECK(IsUseDefChainLinkPresent(value, node));
  }
 
  // Verify all context inputs are value nodes.
  for (int i = 0; i < context_count; ++i) {
    Node* context = NodeProperties::GetContextInput(node);
    CHECK(OperatorProperties::HasValueOutput(context->op()));
    CHECK(IsDefUseChainLinkPresent(context, node));
    CHECK(IsUseDefChainLinkPresent(context, node));
  }
 
  // Verify all effect inputs actually have an effect.
  for (int i = 0; i < effect_count; ++i) {
    Node* effect = NodeProperties::GetEffectInput(node);
    CHECK(OperatorProperties::HasEffectOutput(effect->op()));
    CHECK(IsDefUseChainLinkPresent(effect, node));
    CHECK(IsUseDefChainLinkPresent(effect, node));
  }
 
  // Verify all control inputs are control nodes.
  for (int i = 0; i < control_count; ++i) {
    Node* control = NodeProperties::GetControlInput(node, i);
    CHECK(OperatorProperties::HasControlOutput(control->op()));
    CHECK(IsDefUseChainLinkPresent(control, node));
    CHECK(IsUseDefChainLinkPresent(control, node));
  }
 
  // Verify all successors are projections if multiple value outputs exist.
  if (OperatorProperties::GetValueOutputCount(node->op()) > 1) {
    Node::Uses uses = node->uses();
    for (Node::Uses::iterator it = uses.begin(); it != uses.end(); ++it) {
      CHECK(!NodeProperties::IsValueEdge(it.edge()) ||
            (*it)->opcode() == IrOpcode::kProjection ||
            (*it)->opcode() == IrOpcode::kParameter);
    }
  }
 
  switch (node->opcode()) {
    case IrOpcode::kStart:
      // Start has no inputs.
      CHECK_EQ(0, input_count);
      break;
    case IrOpcode::kEnd:
      // End has no outputs.
      CHECK(!OperatorProperties::HasValueOutput(node->op()));
      CHECK(!OperatorProperties::HasEffectOutput(node->op()));
      CHECK(!OperatorProperties::HasControlOutput(node->op()));
      break;
    case IrOpcode::kDead:
      // Dead is never connected to the graph.
      UNREACHABLE();
    case IrOpcode::kBranch: {
      // Branch uses are IfTrue and IfFalse.
      Node::Uses uses = node->uses();
      bool got_true = false, got_false = false;
      for (Node::Uses::iterator it = uses.begin(); it != uses.end(); ++it) {
        CHECK(((*it)->opcode() == IrOpcode::kIfTrue && !got_true) ||
              ((*it)->opcode() == IrOpcode::kIfFalse && !got_false));
        if ((*it)->opcode() == IrOpcode::kIfTrue) got_true = true;
        if ((*it)->opcode() == IrOpcode::kIfFalse) got_false = true;
      }
      // TODO(rossberg): Currently fails for various tests.
      // CHECK(got_true && got_false);
      break;
    }
    case IrOpcode::kIfTrue:
    case IrOpcode::kIfFalse:
      CHECK_EQ(IrOpcode::kBranch,
               NodeProperties::GetControlInput(node, 0)->opcode());
      break;
    case IrOpcode::kLoop:
    case IrOpcode::kMerge:
      break;
    case IrOpcode::kReturn:
      // TODO(rossberg): check successor is End
      break;
    case IrOpcode::kThrow:
      // TODO(rossberg): what are the constraints on these?
      break;
    case IrOpcode::kParameter: {
      // Parameters have the start node as inputs.
      CHECK_EQ(1, input_count);
      CHECK_EQ(IrOpcode::kStart,
               NodeProperties::GetValueInput(node, 0)->opcode());
      // Parameter has an input that produces enough values.
      int index = OpParameter<int>(node);
      Node* input = NodeProperties::GetValueInput(node, 0);
      // Currently, parameter indices start at -1 instead of 0.
      CHECK_GT(OperatorProperties::GetValueOutputCount(input->op()), index + 1);
      break;
    }
    case IrOpcode::kInt32Constant:
    case IrOpcode::kInt64Constant:
    case IrOpcode::kFloat64Constant:
    case IrOpcode::kExternalConstant:
    case IrOpcode::kNumberConstant:
    case IrOpcode::kHeapConstant:
      // Constants have no inputs.
      CHECK_EQ(0, input_count);
      break;
    case IrOpcode::kPhi: {
      // Phi input count matches parent control node.
      CHECK_EQ(1, control_count);
      Node* control = NodeProperties::GetControlInput(node, 0);
      CHECK_EQ(value_count,
               OperatorProperties::GetControlInputCount(control->op()));
      break;
    }
    case IrOpcode::kEffectPhi: {
      // EffectPhi input count matches parent control node.
      CHECK_EQ(1, control_count);
      Node* control = NodeProperties::GetControlInput(node, 0);
      CHECK_EQ(effect_count,
               OperatorProperties::GetControlInputCount(control->op()));
      break;
    }
    case IrOpcode::kFrameState:
      // TODO(jarin): what are the constraints on these?
      break;
    case IrOpcode::kCall:
      // TODO(rossberg): what are the constraints on these?
      break;
    case IrOpcode::kProjection: {
      // Projection has an input that produces enough values.
      size_t index = OpParameter<size_t>(node);
      Node* input = NodeProperties::GetValueInput(node, 0);
      CHECK_GT(OperatorProperties::GetValueOutputCount(input->op()),
               static_cast<int>(index));
      break;
    }
    default:
      // TODO(rossberg): Check other node kinds.
      break;
  }
 
  if (from_start) {
    reached_from_start.insert(node);
  } else {
    reached_from_end.insert(node);
  }
 
  return GenericGraphVisit::CONTINUE;
}

References CHECK, CHECK_EQ, CHECK_GT, v8::internal::compiler::GenericGraphVisit::CONTINUE, from_start, v8::internal::compiler::NodeProperties::GetContextInput(), v8::internal::compiler::OperatorProperties::GetContextInputCount(), v8::internal::compiler::NodeProperties::GetControlInput(), v8::internal::compiler::OperatorProperties::GetControlInputCount(), v8::internal::compiler::NodeProperties::GetEffectInput(), v8::internal::compiler::OperatorProperties::GetEffectInputCount(), v8::internal::compiler::NodeProperties::GetFrameStateInput(), v8::internal::compiler::OperatorProperties::GetFrameStateInputCount(), v8::internal::compiler::NodeProperties::GetValueInput(), v8::internal::compiler::OperatorProperties::GetValueInputCount(), v8::internal::compiler::OperatorProperties::GetValueOutputCount(), v8::internal::compiler::OperatorProperties::HasControlOutput(), v8::internal::compiler::OperatorProperties::HasEffectOutput(), v8::internal::compiler::OperatorProperties::HasFrameStateInput(), v8::internal::compiler::OperatorProperties::HasValueOutput(), v8::internal::compiler::IsDefUseChainLinkPresent(), v8::internal::compiler::IsUseDefChainLinkPresent(), v8::internal::compiler::NodeProperties::IsValueEdge(), reached_from_end, reached_from_start, and UNREACHABLE.

Here is the call graph for this function:

Member Data Documentation

from_start

bool v8::internal::compiler::Verifier::Visitor::from_start

Definition at line 57 of file verifier.cc.

Referenced by Pre(), and v8::internal::compiler::Verifier::Run().

reached_from_end

NodeSet v8::internal::compiler::Verifier::Visitor::reached_from_end

Definition at line 59 of file verifier.cc.

Referenced by Pre(), and v8::internal::compiler::Verifier::Run().

reached_from_start

NodeSet v8::internal::compiler::Verifier::Visitor::reached_from_start

Definition at line 58 of file verifier.cc.

Referenced by Pre(), and v8::internal::compiler::Verifier::Run().

---

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

• /mnt/V8SourceCode/src/compiler/verifier.cc