#include <ControlFlowGraphPass.hh>

Inheritance diagram for ControlFlowGraphPass:

Collaboration diagram for ControlFlowGraphPass:

Public Member Functions
	ControlFlowGraphPass (InterPassData &data)

virtual	~ControlFlowGraphPass ()

virtual void	handleControlFlowGraph (ControlFlowGraph &cfg, const TTAMachine::Machine &targetMachine)

void	executeBasicBlockPass (ControlFlowGraph &cfg, const TTAMachine::Machine &targetMachine, BasicBlockPass &bbPass)

Public Member Functions inherited from SchedulerPass
	SchedulerPass (InterPassData &data)

virtual	~SchedulerPass ()

InterPassData &	interPassData ()

virtual std::string	shortDescription () const =0

virtual std::string	longDescription () const

Detailed Description

Interface for scheduler passes that handle control flow graphs.

Definition at line 50 of file ControlFlowGraphPass.hh.

Constructor & Destructor Documentation

◆ ControlFlowGraphPass()

ControlFlowGraphPass::ControlFlowGraphPass ( InterPassData & data )

Constructor.

Definition at line 42 of file ControlFlowGraphPass.cc.

                                                              : 
    SchedulerPass(data) {
}

◆ ~ControlFlowGraphPass()

ControlFlowGraphPass::~ControlFlowGraphPass ( )

virtual

Destructor.

Definition at line 49 of file ControlFlowGraphPass.cc.

49 {

50}

Member Function Documentation

◆ executeBasicBlockPass()

void ControlFlowGraphPass::executeBasicBlockPass	(	ControlFlowGraph &	cfg,
		const TTAMachine::Machine &	targetMachine,
		BasicBlockPass &	bbPass
	)

Executes the given basic block pass on each basic block of the given control flow graph in the original program order.

A helper function for implementing most simplest types of CFG passes.

Parameters

cfg	The control flow graph to handle.
targetMachine	The target machine, if any. (NullMachine::instance() if target machine is irrelevant).
bbPass	The basic block pass to execute.

Exceptions

In	case handling is unsuccesful for any reason (cfg might still get modified).

Definition at line 90 of file ControlFlowGraphPass.cc.

                            {
    // first schedule all inner-loop basic blocks.
    int nodeCount = cfg.nodeCount();
    for (int bbIndex = 0; bbIndex < nodeCount; ++bbIndex) {
        BasicBlockNode& bb = dynamic_cast<BasicBlockNode&>(cfg.node(bbIndex));
        if (!bb.isNormalBB() || bb.isScheduled() || !cfg.isSingleBBLoop(bb)) {
            continue;
        }
        bbPass.handleBasicBlock(
            bb.basicBlock(), targetMachine,
            cfg.instructionReferenceManager(), &bb);
        bb.setScheduled();
        // if some node is removed, make sure does not skip some node and
        // then try to handle too many nodes.
        if (cfg.nodeCount() != nodeCount) {
            nodeCount = cfg.nodeCount();
            bbIndex = 0;
        }
    }
 
    // then other basic blocks.
    nodeCount = cfg.nodeCount();
    for (int bbIndex = 0; bbIndex < nodeCount; ++bbIndex) {
        BasicBlockNode& bb = dynamic_cast<BasicBlockNode&>(cfg.node(bbIndex));
        if (!bb.isNormalBB())
            continue;
        if (bb.isScheduled()) {
            continue;
        }
 
        bbPass.handleBasicBlock(
            bb.basicBlock(), targetMachine, 
            cfg.instructionReferenceManager(), &bb);
        bb.setScheduled();
        // if some node is removed, make sure does not skip some node and
        // then try to handle too many nodes.
        if (cfg.nodeCount() != nodeCount) {
            nodeCount = cfg.nodeCount();
            bbIndex = 0;
        }
    }
}

References BasicBlockNode::basicBlock(), BasicBlockPass::handleBasicBlock(), ControlFlowGraph::instructionReferenceManager(), BasicBlockNode::isNormalBB(), BasicBlockNode::isScheduled(), ControlFlowGraph::isSingleBBLoop(), BoostGraph< GraphNode, GraphEdge >::node(), BoostGraph< GraphNode, GraphEdge >::nodeCount(), and BasicBlockNode::setScheduled().

Referenced by handleControlFlowGraph().

Here is the call graph for this function:

◆ handleControlFlowGraph()

void ControlFlowGraphPass::handleControlFlowGraph	(	ControlFlowGraph &	cfg,
		const TTAMachine::Machine &	targetMachine
	)

virtual

Handles a single control flow graph.

The pass should work with any kind of control flow graph, it should not assume the CFG represents a whole procedure, for example.

Parameters

cfg	The control flow graph to handle.
machine	The target machine if any. (NullMachine::instance() if target machine is irrelevant).

Exceptions

In	case handling is unsuccesful for any reason (cfg might still get modified).

Reimplemented in ScheduleEstimator, CallsToJumps, PreOptimizer, SimpleIfConverter, BBSchedulerController, and Peel2BBLoops.

Definition at line 65 of file ControlFlowGraphPass.cc.

                                                                   {
    BasicBlockPass* bbPass = dynamic_cast<BasicBlockPass*>(this);
    if (bbPass != NULL) {
        executeBasicBlockPass(cfg, targetMachine, *bbPass);
    } else {
        abortWithError("CFG Pass is not also a BB pass so you "
                       "must overload handleControlFlowGraph method!");
    }
}

References abortWithError, and executeBasicBlockPass().

Referenced by llvm::LLVMTCEIRBuilder::compileFast(), llvm::LLVMTCEIRBuilder::compileOptimized(), and ProcedurePass::executeControlFlowGraphPass().