CallsToJumps Class Reference

#include <CallsToJumps.hh>

Inheritance diagram for CallsToJumps:

Collaboration diagram for CallsToJumps:

Public Member Functions
	CallsToJumps (InterPassData &data)
virtual	~CallsToJumps ()
virtual void	handleControlFlowGraph (ControlFlowGraph &cfg, const TTAMachine::Machine &targetMachine)
std::string	shortDescription () const
Public Member Functions inherited from ControlFlowGraphPass
	ControlFlowGraphPass (InterPassData &data)
virtual	~ControlFlowGraphPass ()
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	longDescription () const

Detailed Description

Pass that converts all CALL operation calls to a JUMP that succeeds a regular move to RA that stores the address of the instruction following the original CALL.

This pass should be called for an unscheduled CFG before DDG construction.

Definition at line 36 of file CallsToJumps.hh.

Constructor & Destructor Documentation

CallsToJumps()

CallsToJumps::CallsToJumps ( InterPassData &  data )

inline

Definition at line 38 of file CallsToJumps.hh.

: ControlFlowGraphPass(data) {}

~CallsToJumps()

virtual CallsToJumps::~CallsToJumps ( )

inlinevirtual

Definition at line 39 of file CallsToJumps.hh.

{}

Member Function Documentation

handleControlFlowGraph()

void CallsToJumps::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 from ControlFlowGraphPass.

Definition at line 49 of file CallsToJumps.cc.

                                                                   {
    InstructionReferenceManager& irm = 
        cfg.instructionReferenceManager();
    int nodeCount = cfg.nodeCount();
    for (int bbIndex = 0; bbIndex < nodeCount; ++bbIndex) {
        BasicBlockNode& bbn = dynamic_cast<BasicBlockNode&>(cfg.node(bbIndex));
        if (!bbn.isNormalBB())
            continue;
 
        assert(!bbn.isScheduled());
 
        BasicBlock& bb = bbn.basicBlock();
 
        // scan through the instructions, looking for CALLs
        // replace each call with
        // 1) a move to RA with an instruction reference to the instruction
        // following the call (the next BB), and
        // 2) a JUMP to the original CALL destination
        // 3) some kind of annotation that marks that this JUMP should
        //    be treated like a function call, e.g., in the DDG builder
        for (int i = 0, count = bb.instructionCount(); i < count; ++i) {
            Instruction& instr = bb.instructionAtIndex(i);
            if (instr.hasCall()) {
 
                // If unscheduled it should have exactly one move, the call.
                assert(instr.moveCount() == 1);
 
                // In the TCE's CFG, a call splits the basic block, so this
                // should be the last instruction as there are no delay slots
                // in the intermediate representation.
                assert(i + 1 == count);
 
 
                Move& originalCall = instr.move(0);
 
                BasicBlockNode* nextBB = cfg.fallThruSuccessor(bbn);
                assert(nextBB != NULL);
 
#ifdef DEBUG_CALLS_TO_JUMPS
                Application::logStream()
                    << "### found call: " << originalCall.toString()
                    << std::endl;
                Application::logStream()
                    << "### BB: " << bb.toString() << std::endl;
                Application::logStream()
                    << "### FallThroughBB: " << nextBB->basicBlock().toString() 
                    << std::endl;
#endif
 
                // E.g. call to exit does not return and there is no sensible
                // place to return. Just do not add the RA write in that case.
                Instruction* returnLocation = 
                    (nextBB->basicBlock().instructionCount() > 0) ? 
                    &nextBB->basicBlock().firstInstruction() : NULL;
 
                CodeGenerator codeGen(targetMachine);
 
                UniversalMachine& uMach = UniversalMachine::instance();
 
                std::shared_ptr<Move> returnAddressMove = NULL;
                std::shared_ptr<Move> jumpToFunction;
 
                if (originalCall.isUnconditional()) {
 
                    if (returnLocation != NULL) {
                        InstructionReference returnRef = 
                            irm.createReference(*returnLocation);
                
                        returnAddressMove = std::make_shared<Move>(
                            new TerminalInstructionReference(returnRef),
                            new TTAProgram::TerminalFUPort(
                                *uMach.controlUnit()->returnAddressPort()),
                            uMach.universalBus());
                    }
 
                    jumpToFunction = std::make_shared<Move>(
                        originalCall.source().copy(), 
                        codeGen.createTerminalFUPort("jump", 1),
                        uMach.universalBus());
                } else {
 
                    if (returnLocation != NULL) {
                        InstructionReference returnRef = 
                            irm.createReference(*returnLocation);
 
                        returnAddressMove = std::make_shared<Move>(
                            new TerminalInstructionReference(returnRef),
                            new TTAProgram::TerminalFUPort(
                                *uMach.controlUnit()->returnAddressPort()),
                            uMach.universalBus(),
                            originalCall.guard().copy());
                    }
 
                    jumpToFunction = std::make_shared<Move>(
                        originalCall.source().copy(), 
                        codeGen.createTerminalFUPort("jump", 1),
                        uMach.universalBus(),
                        originalCall.guard().copy());
                }
 
                jumpToFunction->addAnnotation(
                    ProgramAnnotation(ProgramAnnotation::ANN_JUMP_FUNCTION_CALL));
 
                if (returnAddressMove != NULL) {
                    Instruction* raMoveInstr =
                        new Instruction(TTAMachine::NullInstructionTemplate::instance());
                    raMoveInstr->addMove(returnAddressMove);
                    bb.insertBefore(instr, raMoveInstr);
                    
                    if (irm.hasReference(instr))
                        irm.replace(instr, *raMoveInstr);
                }
 
                Instruction* jumpInstr =
                    new Instruction(TTAMachine::NullInstructionTemplate::instance());
                jumpInstr->addMove(jumpToFunction);
 
                bb.insertBefore(instr, jumpInstr);
 
                if (returnAddressMove == NULL && irm.hasReference(instr))
                    irm.replace(instr, *jumpInstr);
 
                // Keep the instruction references up to date as
                // the old call can be a jump target (so should be the
                // new RA-move) if it starts a basic block.
 
#ifdef DEBUG_CALLS_TO_JUMPS
                Application::logStream()
                    << "### removing " << instr.toString() << std::endl;
#endif
                assert(!irm.hasReference(instr));
                bb.remove(instr);
            }
        }
    }
}

References TTAProgram::AnnotatedInstructionElement::addAnnotation(), TTAProgram::Instruction::addMove(), TTAProgram::ProgramAnnotation::ANN_JUMP_FUNCTION_CALL, assert, BasicBlockNode::basicBlock(), TTAMachine::Machine::controlUnit(), TTAProgram::MoveGuard::copy(), TTAProgram::Terminal::copy(), TTAProgram::InstructionReferenceManager::createReference(), TTAProgram::CodeGenerator::createTerminalFUPort(), ControlFlowGraph::fallThruSuccessor(), TTAProgram::CodeSnippet::firstInstruction(), TTAProgram::Move::guard(), TTAProgram::Instruction::hasCall(), TTAProgram::InstructionReferenceManager::hasReference(), TTAProgram::CodeSnippet::insertBefore(), TTAMachine::NullInstructionTemplate::instance(), UniversalMachine::instance(), TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), ControlFlowGraph::instructionReferenceManager(), BasicBlockNode::isNormalBB(), BasicBlockNode::isScheduled(), TTAProgram::Move::isUnconditional(), Application::logStream(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), BoostGraph< GraphNode, GraphEdge >::node(), BoostGraph< GraphNode, GraphEdge >::nodeCount(), TTAProgram::CodeSnippet::remove(), TTAProgram::InstructionReferenceManager::replace(), TTAMachine::ControlUnit::returnAddressPort(), TTAProgram::Move::source(), TTAProgram::Move::toString(), TTAProgram::CodeSnippet::toString(), TTAProgram::Instruction::toString(), and UniversalMachine::universalBus().

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

Here is the call graph for this function:

shortDescription()

std::string CallsToJumps::shortDescription ( ) const

inlinevirtual

A short description of the pass, usually the optimization name, such as "basic block scheduler".

Returns

The description as a string.

Implements SchedulerPass.

Definition at line 44 of file CallsToJumps.hh.

                                       {
        return "Converts CALL operations to JUMPs and explicit RA save moves.";
    }

---

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

• CallsToJumps.hh
• CallsToJumps.cc