#include <BasicBlockNode.hh>

Inheritance diagram for BasicBlockNode:

Collaboration diagram for BasicBlockNode:

Public Member Functions
	BasicBlockNode (InstructionAddress originalStartAddress, InstructionAddress originalEndAddress, bool entry=false, bool exit=false)

	BasicBlockNode (TTAProgram::BasicBlock &bb, bool scheduled=false, bool refsUpdated=false, int originalStartAddress=0, bool loopScheduled=false)

virtual	~BasicBlockNode ()

bool	isBasicBlockNode () const

bool	isNormalBB () const

bool	isEntryBB () const

bool	isExitBB () const

std::string	toString () const

TTAProgram::BasicBlock &	basicBlock ()

const TTAProgram::BasicBlock &	basicBlock () const

bool	hasOriginalAddress () const

InstructionAddress	originalStartAddress () const

InstructionAddress	originalEndAddress () const

const TTAProgram::BasicBlockStatistics &	statistics ()

bool	isScheduled () const

void	setScheduled (bool state=true)

std::pair< TTAProgram::Move , TTAProgram::Move >	findJumps ()

void	updateHWloopLength (unsigned len)

void	updateReferencesFromProcToCfg (TTAProgram::Program &prog)

bool	isLoopScheduled () const

void	setLoopScheduled ()

void	setBBOwnership (bool ownership=true)

void	setHWLoop (bool hwloop=true)
	Set true if the bbn is known to be a loop body of a hwloop with loop pattern- preheader BB -> loop body (single BB) -> tail BB. Furthermore, preheader should use HWLOOP instruction for its fallthrough jump to its loop body. More...

bool	isHWLoop () const

const BasicBlockNode *	successor () const

const BasicBlockNode *	predecessor () const

BasicBlockNode *	successor ()

BasicBlockNode *	predecessor ()

void	link (BasicBlockNode *succ)

int	maximumSize () const

void	setMaximumSize (int sz)

Public Member Functions inherited from GraphNode
	GraphNode (int nodeID)

	GraphNode ()

virtual	~GraphNode ()

virtual GraphNode *	clone () const

int	nodeID () const

virtual std::string	dotString () const

Private Attributes
InstructionAddress	originalStartAddress_
	start address of the original basic block, used for reconstructing the original program after modifying the CFG and its nodes More...

InstructionAddress	originalEndAddress_
	end address of the original basic block, used for reconstructing the original program after modifying the CFG and its nodes More...

bool	hasOriginalAddress_
	not all basic blocks have original addresses (completely new basic blocks, etc.), this flag is true in case it does More...

TTAProgram::BasicBlock *	basicBlock_
	the actual payload data of the graph node (the basic block) More...

bool	bbOwned_
	true if the BasicBlock is owned by the BasicBlockNode More...

bool	entry_
	true if this is an entry basic block (not real one) More...

bool	exit_
	true if this is an exit basic block (not real one) More...

bool	scheduled_

bool	refsUpdated_

bool	loopScheduled_

bool	isHardwareLoop_
	true if this bb is known to be a hwloop body More...

BasicBlockNode *	successor_

BasicBlockNode *	predecessor_

int	maximumSize_
	Maximum number of instructions this can consume when scheduled. More...

Detailed Description

Node of the control flow graph. Each node represents one basic block.

A basic block is defined as an ordered sequence of adjacent instructions in which only the first can be target of jump and only the last one (save jump delay slots) can contain jumps.

Note: Instructions that contain function calls are control flow barriers also. For now they split basic blocks into two, with special type of edge connecting them.

Definition at line 64 of file BasicBlockNode.hh.

Constructor & Destructor Documentation

◆ BasicBlockNode() [1/2]

BasicBlockNode::BasicBlockNode	(	InstructionAddress	originalStartAddress,
		InstructionAddress	originalEndAddress,
		bool	entry = `false`,
		bool	exit = `false`
	)

Constructor.

Parameters

originalStartAddress	The starting address of the basic block in the original program (address of the first instruction).
originalEndAddress	The ending address of the basic block in the original program (address of the last instruction).
entry	True if the basic block is a (pseudo) entry basic block.
exit	True if the basic block is a (pseudo) exit basic block.

Definition at line 60 of file BasicBlockNode.cc.

                :
     originalStartAddress_(originalStartAddress),
     originalEndAddress_(originalEndAddress),
     hasOriginalAddress_(true), 
     basicBlock_(new TTAProgram::BasicBlock(originalStartAddress)), 
     bbOwned_(true),
     entry_(entry), exit_(exit),
     scheduled_(false), refsUpdated_(false), loopScheduled_(false),
     isHardwareLoop_(false),
     successor_(NULL), predecessor_(NULL), maximumSize_(INT_MAX) {
  
     if (entry || exit) {
         hasOriginalAddress_ = false;
     } else {
         if (originalStartAddress > originalEndAddress){
             throw InvalidData(
                 __FILE__, __LINE__, __func__, 
                 "Basic block start address is higher then it's end address");
         }                                               
     }
 }

References __func__, hasOriginalAddress_, originalEndAddress(), and originalStartAddress().

Here is the call graph for this function:

◆ BasicBlockNode() [2/2]

BasicBlockNode::BasicBlockNode	(	TTAProgram::BasicBlock &	bb,
		bool	scheduled = `false`,
		bool	refsUpdated = `false`,
		int	originalStartAddress = `0`,
		bool	loopScheduled = `false`
	)

explicit

Constructor.

A wrapper for BasicBlock. When constructed with this one, the given bb will not be deleted in the destructor.

Definition at line 92 of file BasicBlockNode.cc.

                                                   :
     originalStartAddress_(originalStartAddress), originalEndAddress_(0), 
     hasOriginalAddress_(false), basicBlock_(&bb), bbOwned_(false), 
     entry_(false), exit_(false),
     scheduled_(scheduled), refsUpdated_(refsUpdated), 
     loopScheduled_(loopScheduled),
     isHardwareLoop_(false),
     successor_(NULL), predecessor_(NULL), maximumSize_(INT_MAX) {
 }

◆ ~BasicBlockNode()

BasicBlockNode::~BasicBlockNode ( )

virtual

Destructor.

Definition at line 107 of file BasicBlockNode.cc.

                                 {
     if (bbOwned_)
         delete basicBlock_;
     basicBlock_ = NULL;
  
     if (successor_ != nullptr && successor_->predecessor_ == this) {
         successor_->predecessor_ = predecessor_;
     }
     if (predecessor_ != nullptr && predecessor_->successor_ == this) {
         predecessor_->successor_ = successor_;
     }
 }

References basicBlock_, bbOwned_, predecessor_, and successor_.

Member Function Documentation

◆ basicBlock() [1/2]

const TTAProgram::BasicBlock & BasicBlockNode::basicBlock ( )

Returns the basic block object this node represents.

Returns: The basic block object (can be modified).

Returns the basic block object this node represents (const version).

Returns: The basic block object (can be modified).

Definition at line 126 of file BasicBlockNode.cc.

                            {
     return *basicBlock_;
 }

References basicBlock_.

◆ basicBlock() [2/2]

const TTAProgram::BasicBlock& BasicBlockNode::basicBlock ( ) const

◆ findJumps()

std::pair< TTAProgram::Move *, TTAProgram::Move * > BasicBlockNode::findJumps ( )

Finds jumps from a BasicBlockNode.

Returns: second is last jump or NULL if no jumps, first NULL or first jump if the BB has two jumps

Definition at line 283 of file BasicBlockNode.cc.

                           {
     std::pair<TTAProgram::Move*, TTAProgram::Move*> moves(NULL,NULL);
     for (int i = basicBlock_->instructionCount()-1; i >= 0; i--) {
         TTAProgram::Instruction& ins = basicBlock_->instructionAtIndex(i);
         for (int j = 0; j < ins.moveCount(); j++) {
             TTAProgram::Move& move = ins.move(j);
             if (move.isJump()) {
                 if (moves.second == NULL) {
                     moves.second = &move;
                 } else {
                     moves.first = &move;
                     return moves;
                     break;
                 }
             }
         }
     }
     return moves;
 }

References basicBlock_, TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Move::isJump(), TTAProgram::Instruction::move(), and TTAProgram::Instruction::moveCount().

Here is the call graph for this function:

◆ hasOriginalAddress()

bool BasicBlockNode::hasOriginalAddress ( ) const

Returns true if the original adress of this basic block is known.

The basic block might not have original program address in case it's a pseudo basic block, or a completely new basic block which did not exist in the original program.

Returns: True in case original address is known.

Definition at line 150 of file BasicBlockNode.cc.

                                          {
     return hasOriginalAddress_;
 }

References hasOriginalAddress_.

Referenced by ProcedurePass::copyCfgToProcedure().

◆ isBasicBlockNode()

bool BasicBlockNode::isBasicBlockNode ( ) const

inline

Definition at line 77 of file BasicBlockNode.hh.

77 { return true; }

◆ isEntryBB()

bool BasicBlockNode::isEntryBB ( ) const

Returns true if the basic block is representing artificial Entry node.

Returns: True if the basic block is artificially added Entry node.

Definition at line 248 of file BasicBlockNode.cc.

                                 {
     return entry_;
 }

References entry_.

Referenced by ControlDependenceGraph::createPostDominanceTree(), ControlDependenceGraph::detectControlDependencies(), ControlFlowGraph::entryNode(), ControlFlowGraph::fallThroughPredecessor(), ControlDependenceNode::isEntryNode(), and toString().

◆ isExitBB()

bool BasicBlockNode::isExitBB ( ) const

Return true if basic block is representing artificial Exit node.

Returns: True if basic block is Exit node.

Definition at line 257 of file BasicBlockNode.cc.

                                {
     return exit_;
 }

References exit_.

Referenced by ControlFlowGraph::exitNode(), ControlFlowGraph::fallThruSuccessor(), ControlDependenceNode::isExitNode(), and toString().

◆ isHWLoop()

bool BasicBlockNode::isHWLoop ( ) const

inline

Definition at line 114 of file BasicBlockNode.hh.

                      {
         return isHardwareLoop_;
     }

References isHardwareLoop_.

Referenced by BBSchedulerController::executeDDGPass(), and CopyingDelaySlotFiller::fillDelaySlots().

◆ isLoopScheduled()

bool BasicBlockNode::isLoopScheduled ( ) const

inline

Definition at line 101 of file BasicBlockNode.hh.

101 { return loopScheduled_; }

References loopScheduled_.

Referenced by CopyingDelaySlotFiller::fillDelaySlots().

◆ isNormalBB()

bool BasicBlockNode::isNormalBB ( ) const

Returns true if object is ordinary basic block containing code snippet with instructions.

Returns: True if the basic block is normal storage for instructions.

Definition at line 239 of file BasicBlockNode.cc.

                                  {
     return (!entry_) && (!exit_);
 }

References entry_, and exit_.

◆ isScheduled()

bool BasicBlockNode::isScheduled ( ) const

inline

Definition at line 93 of file BasicBlockNode.hh.

93 { return scheduled_; }

References scheduled_.

Referenced by ControlFlowGraph::allScheduledInBetween(), DataDependenceGraphBuilder::constructIndividualBB(), DataDependenceGraphBuilder::constructIndividualFromInlineAsmBB(), ControlFlowGraphPass::executeBasicBlockPass(), BBSchedulerController::handleBBNode(), CallsToJumps::handleControlFlowGraph(), ScheduleEstimator::handleControlFlowGraph(), ControlFlowGraph::optimizeBBOrdering(), ControlFlowGraph::splitBasicBlockAtIndex(), and ControlFlowGraph::splitBB().

◆ link()

void BasicBlockNode::link ( BasicBlockNode * succ )

Definition at line 352 of file BasicBlockNode.cc.

                                                    {
     // this is already the successor!
     if (successor == successor_) {
         assert(successor_->predecessor_ == this);
         return;
     }
  
     // link the new one between previous successor
     if (successor_) {
         auto oldSucc = successor_;
         oldSucc->predecessor_ = successor;
         successor->successor_ = oldSucc;
     }
  
     if (successor != NULL) {
         // make sure no inconsistent links.
         if (successor->predecessor_ != NULL &&
             successor->predecessor_->successor_ == successor) {
             successor->predecessor_->successor_ = NULL;
         }
         successor->predecessor_ = this;
     }
     successor_ = successor;
 }

References assert, predecessor_, successor(), and successor_.

Referenced by ControlFlowGraph::optimizeBBOrdering(), and ControlFlowGraph::splitBB().

Here is the call graph for this function:

◆ maximumSize()

int BasicBlockNode::maximumSize ( ) const

Returns maximum size of a basic block. If scheduled, return the actual size.

If not scheduled, return the size stored in max size field.

Definition at line 384 of file BasicBlockNode.cc.

                                       {
     return scheduled_ ?
         basicBlock().instructionCount() -
         basicBlock().skippedFirstInstructions() :
         maximumSize_;
 }

References basicBlock(), TTAProgram::CodeSnippet::instructionCount(), maximumSize_, scheduled_, and TTAProgram::BasicBlock::skippedFirstInstructions().

Referenced by ControlFlowGraph::findRelJumpDistance().

Here is the call graph for this function:

◆ originalEndAddress()

InstructionAddress BasicBlockNode::originalEndAddress ( ) const

The end address of the basic block in the original program.

Returned value is undefined in case hasOriginalAddress() returns false.

Returns: The original ending address of the basic block.

Definition at line 174 of file BasicBlockNode.cc.

                                          {
     return originalEndAddress_;
 }

References originalEndAddress_.

Referenced by BasicBlockNode(), DataDependenceGraphBuilder::constructIndividualBB(), ProcedurePass::copyCfgToProcedure(), ControlFlowGraph::createControlFlowEdge(), and CompiledSimCodeGenerator::findBasicBlocks().

◆ originalStartAddress()

InstructionAddress BasicBlockNode::originalStartAddress ( ) const

The starting address of the basic block in the original program.

Returned value is undefined in case hasOriginalAddress() returns false.

Returns: The original starting address of the basic block.

Definition at line 162 of file BasicBlockNode.cc.

                                            {
     return originalStartAddress_;
 }

References originalStartAddress_.

Referenced by BasicBlockNode(), LoopPrologAndEpilogBuilder::build(), DataDependenceGraphBuilder::constructIndividualBB(), ProcedurePass::copyCfgToProcedure(), ControlFlowGraph::createControlFlowEdge(), CompiledSimCodeGenerator::findBasicBlocks(), and CopyingDelaySlotFiller::mightFillIncomingTo().

◆ predecessor() [1/2]

BasicBlockNode* BasicBlockNode::predecessor ( )

inline

Definition at line 123 of file BasicBlockNode.hh.

123 { return predecessor_; }

References predecessor_.

◆ predecessor() [2/2]

const BasicBlockNode* BasicBlockNode::predecessor ( ) const

inline

Definition at line 121 of file BasicBlockNode.hh.

121 { return predecessor_; }

References predecessor_.

Referenced by BBSchedulerController::executeDDGPass(), and ControlFlowGraph::findRelJumpDistance().

◆ setBBOwnership()

void BasicBlockNode::setBBOwnership ( bool ownership = true )

inline

Definition at line 103 of file BasicBlockNode.hh.

103 { bbOwned_ = ownership; }

References bbOwned_.

Referenced by llvm::LLVMTCEIRBuilder::buildTCECFG().

◆ setHWLoop()

void BasicBlockNode::setHWLoop ( bool hwloop = true )

inline

Set true if the bbn is known to be a loop body of a hwloop with loop pattern- preheader BB -> loop body (single BB) -> tail BB. Furthermore, preheader should use HWLOOP instruction for its fallthrough jump to its loop body.

Definition at line 110 of file BasicBlockNode.hh.

                                   {
         isHardwareLoop_ = hwloop;
     }

References isHardwareLoop_.

Referenced by llvm::LLVMTCEIRBuilder::buildTCECFG().

◆ setLoopScheduled()

void BasicBlockNode::setLoopScheduled ( )

inline

Definition at line 102 of file BasicBlockNode.hh.

102 { loopScheduled_ = true; }

References loopScheduled_.

◆ setMaximumSize()

void BasicBlockNode::setMaximumSize ( int sz )

inline

Definition at line 128 of file BasicBlockNode.hh.

128 { maximumSize_ = sz; }

References maximumSize_.

Referenced by ScheduleEstimator::handleControlFlowGraph().

◆ setScheduled()

void BasicBlockNode::setScheduled ( bool state = true )

inline

Definition at line 94 of file BasicBlockNode.hh.

94 { scheduled_ = state;}

References scheduled_.

Referenced by LoopPrologAndEpilogBuilder::addEpilogFromRM(), LoopPrologAndEpilogBuilder::addPrologFromRM(), llvm::LLVMTCEIRBuilder::buildTCECFG(), ControlFlowGraphPass::executeBasicBlockPass(), BBSchedulerController::handleBBNode(), ControlFlowGraph::splitBasicBlockAtIndex(), and ControlFlowGraph::splitBB().

◆ statistics()

const TTAProgram::BasicBlockStatistics & BasicBlockNode::statistics ( )

Updates and returns the statistics about Basic Block

Returns: refrence to structure with information about basic block

Definition at line 267 of file BasicBlockNode.cc.

                            {
     if (isNormalBB()) {
         return basicBlock_->statistics();
     }
     TTAProgram::BasicBlockStatistics* bbs = 
         new TTAProgram::BasicBlockStatistics();    
     return *bbs;
 }

References basicBlock_, isNormalBB(), and TTAProgram::BasicBlock::statistics().

Referenced by ControlFlowGraph::statistics().

Here is the call graph for this function:

◆ successor() [1/2]

BasicBlockNode* BasicBlockNode::successor ( )

inline

Definition at line 122 of file BasicBlockNode.hh.

122 { return successor_; }

References successor_.

◆ successor() [2/2]

const BasicBlockNode* BasicBlockNode::successor ( ) const

inline

Definition at line 120 of file BasicBlockNode.hh.

120 { return successor_; }

References successor_.

Referenced by ControlFlowGraph::allScheduledInBetween(), ControlFlowGraph::findRelJumpDistance(), and link().

◆ toString()

std::string BasicBlockNode::toString ( ) const

virtual

Returns the description of basic block as string.

Note: Used in writting graph to .dot file.

Returns: The description of basic block

Reimplemented from GraphNode.

Definition at line 185 of file BasicBlockNode.cc.

                                {
  
     if (isNormalBB()) {
         TCEString content = "";
         int iCount = basicBlock().instructionCount();
         if (iCount > basicBlock().skippedFirstInstructions()) {
             const TTAProgram::Instruction& first = 
                 basicBlock().instructionAtIndex(
                     basicBlock().skippedFirstInstructions());
             if (first.moveCount() > 0 &&
                 first.move(0).hasSourceLineNumber())
                 content << " srclines: " << first.move(0).sourceLineNumber();
  
             const TTAProgram::Instruction& last = 
                 basicBlock().lastInstruction();
             if (last.moveCount() > 0 &&
                 last.move(0).hasSourceLineNumber())
                 content << "-" << last.move(0).sourceLineNumber();
  
             content << "\\n0: ";
             content << first.toString();
  
             // print at most last 4 instructions to (usually) print out the
             for (int i = 3; i >= 0; --i) {
                 int loc = iCount - i - 1;
                 if (loc <= basicBlock().skippedFirstInstructions())
                     continue;
                 const TTAProgram::Instruction& instr = 
                     basicBlock().instructionAtIndex(loc);
                 if (i == 3)
                     content << "\\n...\\n";
                 content << "\\n";
                 content << loc << ": ";
                 content << instr.toString();
             }
         }
         return content;
     } else if (isEntryBB()) {
         return "Entry";
     } else if (isExitBB()) {
         return "Exit";
     }
     return "";
 }

References basicBlock(), TTAProgram::Move::hasSourceLineNumber(), TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), isEntryBB(), isExitBB(), isNormalBB(), TTAProgram::CodeSnippet::lastInstruction(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), TTAProgram::Move::sourceLineNumber(), and TTAProgram::Instruction::toString().

Referenced by LoopPrologAndEpilogBuilder::addEpilogFromRM(), ProgramDependenceGraph::addLeafEdges(), LoopPrologAndEpilogBuilder::addPrologFromRM(), ProgramDependenceGraph::copyRegionEECComponent(), ControlFlowGraph::copyToLLVMMachineFunction(), ControlFlowGraph::copyToProcedure(), ProgramDependenceGraph::createJump(), ControlDependenceGraph::detectControlDependencies(), BBSchedulerController::handleBasicBlock(), ControlFlowGraph::optimizeBBOrdering(), ControlFlowGraph::reverseGuardOnOutEdges(), SimpleIfConverter::successors(), and ControlDependenceNode::toString().

Here is the call graph for this function:

◆ updateHWloopLength()

void BasicBlockNode::updateHWloopLength ( unsigned len )

Update hwloop instruction count.

Definition at line 308 of file BasicBlockNode.cc.

                                                {
     for (int i = 0; i < basicBlock_->instructionCount(); i++) {
         TTAProgram::Instruction& ins = basicBlock_->instructionAtIndex(i);
         for (int j = 0; j < ins.moveCount(); j++) {
             TTAProgram::Move& move = ins.move(j);
             if (move.toString().find("hwloop") != std::string::npos &&
                 move.isTriggering()) {
                 // Only process hwloop instr-length setting
                 auto& s = move.source();
                 assert(s.isImmediate() && "hwloop instruction should be imm");
                 move.setSource(
                     new TTAProgram::TerminalImmediate(SimValue(len, 32)));
             }
         }
     }
 }

References assert, basicBlock_, TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Move::isTriggering(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), TTAProgram::Move::setSource(), TTAProgram::Move::source(), and TTAProgram::Move::toString().

Referenced by BBSchedulerController::executeDDGPass().

Here is the call graph for this function:

◆ updateReferencesFromProcToCfg()

void BasicBlockNode::updateReferencesFromProcToCfg ( TTAProgram::Program & prog )

Updates instruction references to this BB from procedure to cfg

Parameters

prog	program where instructions are.

Definition at line 331 of file BasicBlockNode.cc.

                                                                      {
  
     if (refsUpdated_) { 
         return;
     }
     TTAProgram::InstructionReferenceManager& refManager =
         prog.instructionReferenceManager();
     
     if (isNormalBB()) {
         if (basicBlock_->instructionCount() > 0) {
             TTAProgram::Instruction& newIns = basicBlock_->firstInstruction();
             TTAProgram::Instruction& oldIns = prog.instructionAt(
                 originalStartAddress_);
             if (refManager.hasReference(oldIns)) {
                 refManager.replace(oldIns, newIns);
             }
         }
     }
     refsUpdated_ = true;
 }

References basicBlock_, TTAProgram::CodeSnippet::firstInstruction(), TTAProgram::InstructionReferenceManager::hasReference(), TTAProgram::Program::instructionAt(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Program::instructionReferenceManager(), isNormalBB(), originalStartAddress_, refsUpdated_, and TTAProgram::InstructionReferenceManager::replace().

Referenced by ControlFlowGraph::updateReferencesFromProcToCfg().

Here is the call graph for this function:

Member Data Documentation

◆ basicBlock_

TTAProgram::BasicBlock* BasicBlockNode::basicBlock_

private

the actual payload data of the graph node (the basic block)

Definition at line 140 of file BasicBlockNode.hh.

Referenced by basicBlock(), findJumps(), statistics(), updateHWloopLength(), updateReferencesFromProcToCfg(), and ~BasicBlockNode().

◆ bbOwned_

bool BasicBlockNode::bbOwned_

private

true if the BasicBlock is owned by the BasicBlockNode

Definition at line 142 of file BasicBlockNode.hh.

Referenced by setBBOwnership(), and ~BasicBlockNode().

◆ entry_

bool BasicBlockNode::entry_

private

true if this is an entry basic block (not real one)

Definition at line 144 of file BasicBlockNode.hh.

Referenced by isEntryBB(), and isNormalBB().

◆ exit_

bool BasicBlockNode::exit_

private

true if this is an exit basic block (not real one)

Definition at line 146 of file BasicBlockNode.hh.

Referenced by isExitBB(), and isNormalBB().

◆ hasOriginalAddress_

bool BasicBlockNode::hasOriginalAddress_

private

not all basic blocks have original addresses (completely new basic blocks, etc.), this flag is true in case it does

Definition at line 138 of file BasicBlockNode.hh.

Referenced by BasicBlockNode(), and hasOriginalAddress().

◆ isHardwareLoop_

bool BasicBlockNode::isHardwareLoop_

private

true if this bb is known to be a hwloop body

Definition at line 153 of file BasicBlockNode.hh.

Referenced by isHWLoop(), and setHWLoop().

◆ loopScheduled_

bool BasicBlockNode::loopScheduled_

private

Definition at line 151 of file BasicBlockNode.hh.

Referenced by isLoopScheduled(), and setLoopScheduled().

◆ maximumSize_

int BasicBlockNode::maximumSize_

private

Maximum number of instructions this can consume when scheduled.

Definition at line 159 of file BasicBlockNode.hh.

Referenced by maximumSize(), and setMaximumSize().

◆ originalEndAddress_

InstructionAddress BasicBlockNode::originalEndAddress_

private

end address of the original basic block, used for reconstructing the original program after modifying the CFG and its nodes

Definition at line 135 of file BasicBlockNode.hh.

Referenced by originalEndAddress().

◆ originalStartAddress_

InstructionAddress BasicBlockNode::originalStartAddress_

private

start address of the original basic block, used for reconstructing the original program after modifying the CFG and its nodes

Definition at line 132 of file BasicBlockNode.hh.

Referenced by originalStartAddress(), and updateReferencesFromProcToCfg().

◆ predecessor_

BasicBlockNode* BasicBlockNode::predecessor_

private

Definition at line 156 of file BasicBlockNode.hh.

Referenced by link(), predecessor(), and ~BasicBlockNode().

◆ refsUpdated_

bool BasicBlockNode::refsUpdated_

private

Definition at line 149 of file BasicBlockNode.hh.

Referenced by updateReferencesFromProcToCfg().

◆ scheduled_

bool BasicBlockNode::scheduled_

private

Definition at line 148 of file BasicBlockNode.hh.

Referenced by isScheduled(), maximumSize(), and setScheduled().

◆ successor_

BasicBlockNode* BasicBlockNode::successor_

private

Definition at line 155 of file BasicBlockNode.hh.

Referenced by link(), successor(), and ~BasicBlockNode().

The documentation for this class was generated from the following files:

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ BasicBlockNode() [1/2]

◆ BasicBlockNode() [2/2]

◆ ~BasicBlockNode()

Member Function Documentation

◆ basicBlock() [1/2]

◆ basicBlock() [2/2]

◆ findJumps()

◆ hasOriginalAddress()

◆ isBasicBlockNode()

◆ isEntryBB()

◆ isExitBB()

◆ isHWLoop()

◆ isLoopScheduled()

◆ isNormalBB()

◆ isScheduled()

◆ link()

◆ maximumSize()

◆ originalEndAddress()

◆ originalStartAddress()

◆ predecessor() [1/2]

◆ predecessor() [2/2]

◆ setBBOwnership()

◆ setHWLoop()

◆ setLoopScheduled()

◆ setMaximumSize()

◆ setScheduled()

◆ statistics()

◆ successor() [1/2]

◆ successor() [2/2]

◆ toString()

◆ updateHWloopLength()

◆ updateReferencesFromProcToCfg()

Member Data Documentation

◆ basicBlock_

◆ bbOwned_

◆ entry_

◆ exit_

◆ hasOriginalAddress_

◆ isHardwareLoop_

◆ loopScheduled_

◆ maximumSize_

◆ originalEndAddress_

◆ originalStartAddress_

◆ predecessor_

◆ refsUpdated_

◆ scheduled_

◆ successor_