chromium/v8/src/compiler/state-values-utils.cc

// Copyright 2015 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/state-values-utils.h"

#include "src/compiler/bytecode-liveness-map.h"
#include "src/compiler/common-operator.h"

namespace v8 {
namespace internal {
namespace compiler {

StateValuesCache::StateValuesCache(JSGraph* js_graph)
    : … { … }


// static
bool StateValuesCache::AreKeysEqual(void* key1, void* key2) { … }


// static
bool StateValuesCache::IsKeysEqualToNode(StateValuesKey* key, Node* node) { … }


// static
bool StateValuesCache::AreValueKeysEqual(StateValuesKey* key1,
                                         StateValuesKey* key2) { … }


Node* StateValuesCache::GetEmptyStateValues() { … }

StateValuesCache::WorkingBuffer* StateValuesCache::GetWorkingSpace(
    size_t level) { … }

namespace {

int StateValuesHashKey(Node** nodes, size_t count) { … }

}  // namespace

Node* StateValuesCache::GetValuesNodeFromCache(Node** nodes, size_t count,
                                               SparseInputMask mask) { … }

SparseInputMask::BitMaskType StateValuesCache::FillBufferWithValues(
    WorkingBuffer* node_buffer, size_t* node_count, size_t* values_idx,
    Node** values, size_t count, const BytecodeLivenessState* liveness) { … }

Node* StateValuesCache::BuildTree(size_t* values_idx, Node** values,
                                  size_t count,
                                  const BytecodeLivenessState* liveness,
                                  size_t level) { … }

#if DEBUG
namespace {

void CheckTreeContainsValues(Node* tree, Node** values, size_t count,
                             const BytecodeLivenessState* liveness) { … }

}  // namespace
#endif

Node* StateValuesCache::GetNodeForValues(
    Node** values, size_t count, const BytecodeLivenessState* liveness) { … }

StateValuesAccess::iterator::iterator(Node* node) : … { … }

SparseInputMask::InputIterator* StateValuesAccess::iterator::Top() { … }

void StateValuesAccess::iterator::Push(Node* node) { … }


void StateValuesAccess::iterator::Pop() { … }

void StateValuesAccess::iterator::Advance() { … }

size_t StateValuesAccess::iterator::AdvanceTillNotEmpty() { … }

void StateValuesAccess::iterator::EnsureValid() { … }

Node* StateValuesAccess::iterator::node() { … }

MachineType StateValuesAccess::iterator::type() { … }

bool StateValuesAccess::iterator::operator!=(iterator const& other) const { … }

StateValuesAccess::iterator& StateValuesAccess::iterator::operator++() { … }


StateValuesAccess::TypedNode StateValuesAccess::iterator::operator*() { … }

size_t StateValuesAccess::size() const { … }

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