chromium/v8/src/compiler/node.cc

// Copyright 2013 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/compiler/node.h"

namespace v8 {
namespace internal {
namespace compiler {

Node::OutOfLineInputs* Node::OutOfLineInputs::New(Zone* zone, int capacity) { … }

void Node::OutOfLineInputs::ExtractFrom(Use* old_use_ptr,
                                        ZoneNodePtr* old_input_ptr, int count) { … }

// These structs are just type tags for Zone::Allocate<T>(size_t) calls.
struct NodeWithOutOfLineInputs { … };
struct NodeWithInLineInputs { … };

template <typename NodePtrT>
Node* Node::NewImpl(Zone* zone, NodeId id, const Operator* op, int input_count,
                    NodePtrT const* inputs, bool has_extensible_inputs) { … }

Node* Node::New(Zone* zone, NodeId id, const Operator* op, int input_count,
                Node* const* inputs, bool has_extensible_inputs) { … }

Node* Node::Clone(Zone* zone, NodeId id, const Node* node) { … }


void Node::Kill() { … }


void Node::AppendInput(Zone* zone, Node* new_to) { … }


void Node::InsertInput(Zone* zone, int index, Node* new_to) { … }

void Node::InsertInputs(Zone* zone, int index, int count) { … }

Node* Node::RemoveInput(int index) { … }

void Node::ClearInputs(int start, int count) { … }


void Node::NullAllInputs() { … }


void Node::TrimInputCount(int new_input_count) { … }

void Node::EnsureInputCount(Zone* zone, int new_input_count) { … }

int Node::UseCount() const { … }

int Node::BranchUseCount() const { … }

void Node::ReplaceUses(Node* that) { … }

bool Node::OwnedBy(Node const* owner) const { … }

bool Node::OwnedBy(Node const* owner1, Node const* owner2) const { … }

void Node::Print(int depth) const { … }

namespace {
void PrintNode(const Node* node, std::ostream& os, int depth,
               int indentation = 0) { … }
}  // namespace

void Node::Print(std::ostream& os, int depth) const { … }

std::ostream& operator<<(std::ostream& os, const Node& n) { … }

Node::Node(NodeId id, const Operator* op, int inline_count, int inline_capacity)
    : … { … }

void Node::AppendUse(Use* use) { … }


void Node::RemoveUse(Use* use) { … }


#if DEBUG
void Node::Verify() { … }
#endif

Node::InputEdges::iterator Node::InputEdges::iterator::operator++(int n) { … }


Node::Inputs::const_iterator Node::Inputs::const_iterator::operator++(int n) { … }


Node::UseEdges::iterator Node::UseEdges::iterator::operator++(int n) { … }


bool Node::UseEdges::empty() const { … }


Node::Uses::const_iterator Node::Uses::const_iterator::operator++(int n) { … }


bool Node::Uses::empty() const { … }

}  // namespace compiler
}  // namespace internal
}  // namespace v8

V8_DONT_STRIP_SYMBOL
V8_EXPORT_PRIVATE extern void _v8_internal_Node_Print(void* object) { … }