ProcedurePass Class Reference

#include <ProcedurePass.hh>

Inheritance diagram for ProcedurePass:

Collaboration diagram for ProcedurePass:

Public Member Functions
	ProcedurePass (InterPassData &data)
virtual	~ProcedurePass ()
virtual void	handleProcedure (TTAProgram::Procedure &procedure, const TTAMachine::Machine &targetMachine)
Public Member Functions inherited from SchedulerPass
	SchedulerPass (InterPassData &data)
virtual	~SchedulerPass ()
InterPassData &	interPassData ()
virtual std::string	shortDescription () const =0
virtual std::string	longDescription () const

Static Public Member Functions
static void	copyCfgToProcedure (TTAProgram::Procedure &procedure, ControlFlowGraph &cfg)
static void	executeControlFlowGraphPass (TTAProgram::Procedure &procedure, const TTAMachine::Machine &targetmachine, ControlFlowGraphPass &cfgp)

Detailed Description

Interface for scheduler passes that handle procedures.

Definition at line 53 of file ProcedurePass.hh.

Constructor & Destructor Documentation

ProcedurePass()

ProcedurePass::ProcedurePass

(

InterPassData &

data

)

Constructor.

Definition at line 53 of file ProcedurePass.cc.

                                                : 
    SchedulerPass(data) {
}

~ProcedurePass()

ProcedurePass::~ProcedurePass ( )

virtual

Destructor.

Definition at line 60 of file ProcedurePass.cc.

                              {
}

Member Function Documentation

copyCfgToProcedure()

void ProcedurePass::copyCfgToProcedure ( TTAProgram::Procedure &  procedure, ControlFlowGraph &  cfg  )

static

Definition at line 86 of file ProcedurePass.cc.

                                                           {
    TTAProgram::InstructionReferenceManager& irm = 
        procedure.parent().instructionReferenceManager();
    
    int insCountDelta = 0;
 
    // collect the starting point instructions to keep as place holders
    typedef std::map<const BasicBlockNode*, TTAProgram::Instruction*,
        BasicBlockNode::Comparator> PlaceHolders;
    PlaceHolders placeHolders;
 
    // store pointers to al original instrs so we can remove them
    std::set<TTAProgram::Instruction*> originalInstr;
    for (int i = 0; i < procedure.instructionCount(); i++) {
        originalInstr.insert(&procedure.instructionAtIndex(i));
    }
 
    for (int bbIndex = 0; bbIndex < cfg.nodeCount(); ++bbIndex) {
        BasicBlockNode& bb = dynamic_cast<BasicBlockNode&>(cfg.node(bbIndex));
        if (!bb.isNormalBB())
            continue;
        if (!bb.hasOriginalAddress()) 
            throw Exception(
                __FILE__, __LINE__, __func__, 
                "Cannot replace a basic block without original address.");
        placeHolders[&bb] = &procedure.instructionAt(bb.originalStartAddress());
    }
 
    for (int bbIndex = 0; bbIndex < cfg.nodeCount(); ++bbIndex) {
        BasicBlockNode& bb = dynamic_cast<BasicBlockNode&>(cfg.node(bbIndex));
 
        if (!bb.isNormalBB())
            continue;
     
        PlaceHolders::iterator placeHolderIter = placeHolders.find(&bb);
        TTAProgram::Instruction& placeHolder = *placeHolderIter->second;
        placeHolders.erase(placeHolderIter);
 
        // Remove all original instructions (after the place holder first
        // instruction) from the procedure as we are dealing with basic blocks,
        // we can assume that only at most the first instruction is referred to.
        const int originalBBSize = 
            bb.originalEndAddress() - bb.originalStartAddress() + 1;
        int addr = placeHolder.address().location() + 1;
        for (int i = 1; i < originalBBSize; ++i) {
            TTAProgram::Instruction& ins = 
                procedure.instructionAt(addr);
            originalInstr.erase(&ins);
            procedure.CodeSnippet::remove(ins);
            delete &ins;
            insCountDelta--;
        }
 
        TTAProgram::Instruction* firstNewInstruction = NULL;
        TTAProgram::Instruction* lastNewInstruction = &placeHolder;
 
        // consistency check.
        for (int i = 0; i < bb.basicBlock().skippedFirstInstructions(); i++) {
            TTAProgram::Instruction& ins =
                bb.basicBlock().instructionAtIndex(i);
            if (irm.hasReference(ins)) {
                throw IllegalProgram(__FILE__,__LINE__, __func__, 
                                     "Skipped ins has a ref");
            }
        }
 
        // Copy the instructions from the scheduled basic block back 
        // to the program.
        for (int i = bb.basicBlock().skippedFirstInstructions(); 
             i < bb.basicBlock().instructionCount(); ++i) {
            TTAProgram::Instruction& instrToCopy =
                bb.basicBlock().instructionAtIndex(i);
            TTAProgram::Instruction* newInstruction = instrToCopy.copy();
            procedure.insertAfter(
                *lastNewInstruction, newInstruction);
            // update references..
            if (irm.hasReference(instrToCopy)) {
                irm.replace(instrToCopy,*newInstruction);
            }
            lastNewInstruction = newInstruction;
            if (firstNewInstruction == NULL)
                firstNewInstruction = newInstruction;
        }
 
        // replace all references to the placeholder instruction to point to
        // the new first instruction
        if (procedure.parent().instructionReferenceManager().hasReference(
                placeHolder)) {
            assert(firstNewInstruction != NULL);
            procedure.parent().instructionReferenceManager().replace(
                placeHolder, *firstNewInstruction);
        } 
        // now we can delete also the place holder old instruction
        // @todo what if the instruction itself had a reference?
        originalInstr.erase(&placeHolder);
 
        // might have code labels so do not optimize this
        procedure.remove(placeHolder);
        delete &placeHolder;
        // ...and we're done with this basic block
    }
 
    // refs to dead instructions are dead refs but there is no way to
    // remove insr refs. so replace them to refs to first instr.
//    TTAProgram::Instruction& firstIns = procedure.instructionAtIndex(0);
 
    // delete dead instructios (ones from the original procedure
    for(std::set<TTAProgram::Instruction*>::iterator i = 
            originalInstr.begin(); i != originalInstr.end(); i++) {
        TTAProgram::Instruction* ins = *i;
        assert(!irm.hasReference(*ins));
        procedure.CodeSnippet::remove(*ins);
        delete ins;
        insCountDelta--;
    }
 
    // fix the addresses of following procedures. 
    if (insCountDelta != 0) {
        if (procedure.isInProgram()) {
            if (!(&procedure == &procedure.parent().lastProcedure())) {
                procedure.parent().moveProcedure(
                    procedure.parent().nextProcedure(procedure), 
                    insCountDelta);
            }
        }
    }
 
    // scan for meaningless jumps and remove them.
    // currently does not work for jump addresses in long immediates,
    // just ignores them.
    // but this gets rid of unnecessary jumps after tce side if conversion.
    for (int i = 0; i < procedure.instructionCount()-1; i++) {
        TTAProgram::Instruction& ins = procedure.instructionAtIndex(i);
        for (int j = 0; j < ins.moveCount(); j++) {
            TTAProgram::Move& move = ins.move(j);
            // jump those target is easily known?
            if (move.isJump() && move.source().isInstructionAddress()) {
                TTAProgram::TerminalInstructionAddress& tia =
                    dynamic_cast<TTAProgram::TerminalInstructionAddress&>(
                        move.source());
                TTAProgram::Instruction& targetIns = 
                    tia.instructionReference().instruction();
                TTAProgram::TerminalFUPort& tfp = 
                    dynamic_cast<TTAProgram::TerminalFUPort&>(
                        move.destination());
                const TTAMachine::FunctionUnit* fu = &tfp.functionUnit();
                const TTAMachine::ControlUnit* gcu = 
                    dynamic_cast<const TTAMachine::ControlUnit*>(fu);
 
                // index of the instruction after delay slots
                int nextIndex = gcu == NULL ? 
                    i+1 : 
                    i+1+ gcu->delaySlots();
                
                // is index inside the procedure?
                if (nextIndex < procedure.instructionCount()) {
                    TTAProgram::Instruction& nextIns = 
                        procedure.instructionAtIndex(nextIndex);
                    // if jump to next ins, remove jump
                    if (&targetIns == &nextIns) {
                        ins.removeMove(move);
                        delete &move;
                    }
                }
            }
        }
    }
}

References __func__, TTAProgram::Instruction::address(), assert, BasicBlockNode::basicBlock(), TTAProgram::Instruction::copy(), TTAMachine::ControlUnit::delaySlots(), TTAProgram::Move::destination(), TTAProgram::TerminalFUPort::functionUnit(), BasicBlockNode::hasOriginalAddress(), TTAProgram::InstructionReferenceManager::hasReference(), TTAProgram::Procedure::insertAfter(), TTAProgram::InstructionReference::instruction(), TTAProgram::CodeSnippet::instructionAt(), TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Terminal::instructionReference(), TTAProgram::Program::instructionReferenceManager(), TTAProgram::CodeSnippet::isInProgram(), TTAProgram::Terminal::isInstructionAddress(), TTAProgram::Move::isJump(), BasicBlockNode::isNormalBB(), TTAProgram::Program::lastProcedure(), TTAProgram::Address::location(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), TTAProgram::Program::moveProcedure(), TTAProgram::Program::nextProcedure(), BoostGraph< GraphNode, GraphEdge >::node(), BoostGraph< GraphNode, GraphEdge >::nodeCount(), BasicBlockNode::originalEndAddress(), BasicBlockNode::originalStartAddress(), TTAProgram::CodeSnippet::parent(), TTAProgram::Procedure::remove(), TTAProgram::Instruction::removeMove(), TTAProgram::InstructionReferenceManager::replace(), TTAProgram::BasicBlock::skippedFirstInstructions(), and TTAProgram::Move::source().

Referenced by executeControlFlowGraphPass().

Here is the call graph for this function:

executeControlFlowGraphPass()

void ProcedurePass::executeControlFlowGraphPass ( TTAProgram::Procedure &  procedure, const TTAMachine::Machine &  targetmachine, ControlFlowGraphPass &  cfgp  )

static

Definition at line 257 of file ProcedurePass.cc.

                                {
    ControlFlowGraph cfg(procedure);
    cfgp.handleControlFlowGraph(cfg, targetMachine);
    copyCfgToProcedure(procedure, cfg);
}

References copyCfgToProcedure(), and ControlFlowGraphPass::handleControlFlowGraph().

Referenced by handleProcedure().

Here is the call graph for this function:

handleProcedure()

void ProcedurePass::handleProcedure ( TTAProgram::Procedure &  procedure, const TTAMachine::Machine &  targetMachine  )

virtual

Handles a single procedure.

Parameters

proecude	The procedure to handle.
machine	The target machine if any. (NullMachine::instance() if target machine is irrelevant).

Exceptions

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

Reimplemented in PreOptimizer, SequentialScheduler, SimpleIfConverter, AbsoluteToRelativeJumps, and BBSchedulerController.

Definition at line 73 of file ProcedurePass.cc.

                                            {
    ControlFlowGraphPass* cfgPass = dynamic_cast<ControlFlowGraphPass*>(this);
    if (cfgPass != NULL) {
        executeControlFlowGraphPass(procedure, targetMachine, *cfgPass);
    } else {
        abortWithError("Procedure pass is not also a cfg pass so you "
                       "must overload handleProcedure method!");
    }
}

References abortWithError, and executeControlFlowGraphPass().

Referenced by ProgramPass::executeProcedurePass().

Here is the call graph for this function:

---

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

• ProcedurePass.hh
• ProcedurePass.cc