chromium/v8/src/compiler/js-inlining-heuristic.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/js-inlining-heuristic.h"

#include "src/compiler/common-operator.h"
#include "src/compiler/compiler-source-position-table.h"
#include "src/compiler/js-heap-broker.h"
#include "src/compiler/node-matchers.h"
#include "src/compiler/simplified-operator.h"

namespace v8 {
namespace internal {
namespace compiler {

#define TRACE …

namespace {
bool IsSmall(int const size) { … }

bool CanConsiderForInlining(JSHeapBroker* broker,
                            FeedbackCellRef feedback_cell) { … }

bool CanConsiderForInlining(JSHeapBroker* broker, JSFunctionRef function) { … }

}  // namespace

JSInliningHeuristic::Candidate JSInliningHeuristic::CollectFunctions(
    Node* node, int functions_size) { … }

Reduction JSInliningHeuristic::Reduce(Node* node) { … }

void JSInliningHeuristic::Finalize() { … }

namespace {

struct NodeAndIndex { … };

bool CollectStateValuesOwnedUses(Node* node, Node* state_values,
                                 NodeAndIndex* uses_buffer, size_t* use_count,
                                 size_t max_uses) { … }

}  // namespace

Node* JSInliningHeuristic::DuplicateStateValuesAndRename(Node* state_values,
                                                         Node* from, Node* to,
                                                         StateCloneMode mode) { … }

namespace {

bool CollectFrameStateUniqueUses(Node* node, FrameState frame_state,
                                 NodeAndIndex* uses_buffer, size_t* use_count,
                                 size_t max_uses) { … }

}  // namespace

FrameState JSInliningHeuristic::DuplicateFrameStateAndRename(
    FrameState frame_state, Node* from, Node* to, StateCloneMode mode) { … }

bool JSInliningHeuristic::TryReuseDispatch(Node* node, Node* callee,
                                           Node** if_successes, Node** calls,
                                           Node** inputs, int input_count,
                                           int* num_calls) { … }

void JSInliningHeuristic::CreateOrReuseDispatch(
    Node* node, Node* callee, Candidate const& candidate, Node** if_successes,
    Node** calls, Node** inputs, int input_count, int* num_calls) { … }

Reduction JSInliningHeuristic::InlineCandidate(Candidate const& candidate,
                                               bool small_function) { … }

bool JSInliningHeuristic::CandidateCompare::operator()(
    const Candidate& left, const Candidate& right) const { … }

void JSInliningHeuristic::PrintCandidates() { … }

Graph* JSInliningHeuristic::graph() const { … }

CompilationDependencies* JSInliningHeuristic::dependencies() const { … }

CommonOperatorBuilder* JSInliningHeuristic::common() const { … }

SimplifiedOperatorBuilder* JSInliningHeuristic::simplified() const { … }

#undef TRACE

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