schedule.cc | Explore in Territory

// 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/schedule.h"

#include "src/compiler/node-properties.h"
#include "src/compiler/node.h"
#include "src/utils/ostreams.h"

namespace v8 {
namespace internal {
namespace compiler {

BasicBlock::BasicBlock(Zone* zone, Id id)
    : … { … }

bool BasicBlock::LoopContains(BasicBlock* block) const { … }

void BasicBlock::AddSuccessor(BasicBlock* successor) { … }

void BasicBlock::AddPredecessor(BasicBlock* predecessor) { … }

void BasicBlock::RemovePredecessor(size_t index) { … }

void BasicBlock::AddNode(Node* node) { … }

void BasicBlock::set_control(Control control) { … }

void BasicBlock::set_control_input(Node* control_input) { … }

void BasicBlock::set_loop_depth(int32_t loop_depth) { … }

void BasicBlock::set_rpo_number(int32_t rpo_number) { … }

void BasicBlock::set_loop_end(BasicBlock* loop_end) { … }

void BasicBlock::set_loop_header(BasicBlock* loop_header) { … }

void BasicBlock::TrimNodes(iterator new_end) { … }

void BasicBlock::ResetRPOInfo() { … }

// static
BasicBlock* BasicBlock::GetCommonDominator(BasicBlock* b1, BasicBlock* b2) { … }

void BasicBlock::Print() { … }

std::ostream& operator<<(std::ostream& os, const BasicBlock& block) { … }

std::ostream& operator<<(std::ostream& os, const BasicBlock::Control& c) { … }

std::ostream& operator<<(std::ostream& os, const BasicBlock::Id& id) { … }

Schedule::Schedule(Zone* zone, size_t node_count_hint)
    : … { … }

BasicBlock* Schedule::block(Node* node) const { … }

bool Schedule::IsScheduled(Node* node) { … }

BasicBlock* Schedule::GetBlockById(BasicBlock::Id block_id) { … }

void Schedule::ClearBlockById(BasicBlock::Id block_id) { … }

bool Schedule::SameBasicBlock(Node* a, Node* b) const { … }

BasicBlock* Schedule::NewBasicBlock() { … }

void Schedule::PlanNode(BasicBlock* block, Node* node) { … }

void Schedule::AddNode(BasicBlock* block, Node* node) { … }

void Schedule::AddGoto(BasicBlock* block, BasicBlock* succ) { … }

#if DEBUG
namespace {

bool IsPotentiallyThrowingCall(IrOpcode::Value opcode) { … }

}  // namespace
#endif  // DEBUG

void Schedule::AddCall(BasicBlock* block, Node* call, BasicBlock* success_block,
                       BasicBlock* exception_block) { … }

void Schedule::AddBranch(BasicBlock* block, Node* branch, BasicBlock* tblock,
                         BasicBlock* fblock) { … }

void Schedule::AddSwitch(BasicBlock* block, Node* sw, BasicBlock** succ_blocks,
                         size_t succ_count) { … }

void Schedule::AddTailCall(BasicBlock* block, Node* input) { … }

void Schedule::AddReturn(BasicBlock* block, Node* input) { … }

void Schedule::AddDeoptimize(BasicBlock* block, Node* input) { … }

void Schedule::AddThrow(BasicBlock* block, Node* input) { … }

void Schedule::InsertBranch(BasicBlock* block, BasicBlock* end, Node* branch,
                            BasicBlock* tblock, BasicBlock* fblock) { … }

void Schedule::InsertSwitch(BasicBlock* block, BasicBlock* end, Node* sw,
                            BasicBlock** succ_blocks, size_t succ_count) { … }

void Schedule::EnsureCFGWellFormedness() { … }

void Schedule::EliminateRedundantPhiNodes() { … }

void Schedule::EnsureSplitEdgeForm(BasicBlock* block) { … }

void Schedule::MovePhis(BasicBlock* from, BasicBlock* to) { … }

void Schedule::PropagateDeferredMark() { … }

void Schedule::AddSuccessor(BasicBlock* block, BasicBlock* succ) { … }

void Schedule::MoveSuccessors(BasicBlock* from, BasicBlock* to) { … }

void Schedule::SetControlInput(BasicBlock* block, Node* node) { … }

void Schedule::SetBlockForNode(BasicBlock* block, Node* node) { … }

std::ostream& operator<<(std::ostream& os, const Schedule& s) { … }

}  // namespace compiler
}  // namespace internal
}  // namespace v8
chromium/v8/src/compiler/schedule.cc
