AbsoluteToRelativeJumps Class Reference

#include <AbsoluteToRelativeJumps.hh>

Inheritance diagram for AbsoluteToRelativeJumps:

Collaboration diagram for AbsoluteToRelativeJumps:

Public Member Functions
	AbsoluteToRelativeJumps (InterPassData &ipd)
virtual void	handleProcedure (TTAProgram::Procedure &procedure, const TTAMachine::Machine &targetMachine) override
virtual std::string	shortDescription () const override
Public Member Functions inherited from ProcedurePass
	ProcedurePass (InterPassData &data)
virtual	~ProcedurePass ()
Public Member Functions inherited from SchedulerPass
	SchedulerPass (InterPassData &data)
virtual	~SchedulerPass ()
InterPassData &	interPassData ()
virtual std::string	longDescription () const
Public Member Functions inherited from ProgramPass
	ProgramPass (InterPassData &data)
virtual	~ProgramPass ()
virtual void	handleProgram (TTAProgram::Program &program, const TTAMachine::Machine &targetMachine)

Additional Inherited Members
Static Public Member Functions inherited from ProcedurePass
static void	copyCfgToProcedure (TTAProgram::Procedure &procedure, ControlFlowGraph &cfg)
static void	executeControlFlowGraphPass (TTAProgram::Procedure &procedure, const TTAMachine::Machine &targetmachine, ControlFlowGraphPass &cfgp)
Static Public Member Functions inherited from ProgramPass
static void	executeProcedurePass (TTAProgram::Program &program, const TTAMachine::Machine &targetMachine, ProcedurePass &procedurePass)

Detailed Description

Definition at line 39 of file AbsoluteToRelativeJumps.hh.

Constructor & Destructor Documentation

AbsoluteToRelativeJumps()

AbsoluteToRelativeJumps::AbsoluteToRelativeJumps ( InterPassData &  ipd )

inline

Definition at line 43 of file AbsoluteToRelativeJumps.hh.

                                                : 
        ProcedurePass(ipd), ProgramPass(ipd) {}

Member Function Documentation

handleProcedure()

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

overridevirtual

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 from ProcedurePass.

Definition at line 52 of file AbsoluteToRelativeJumps.cc.

                                            {
 
    std::map<TTAProgram::Move*, int> jumpOffsetMoves;
    std::map<std::shared_ptr<TTAProgram::Immediate>, int> jumpOffsetLimms;
 
    auto cu = targetMachine.controlUnit();
    if (!cu->hasOperation("reljump")) {
        return;
    } 
 
    auto& irm = procedure.parent().instructionReferenceManager();
    auto hwop = cu->operation("reljump");
    
    for (int i = 0; i < procedure.instructionCount(); i++) {
        auto& ins = procedure[i];
        for (int j = 0; j < ins.moveCount(); j++) {
            auto& m = ins.move(j);
            auto& src = m.source();
            auto& dst = m.destination();
            if (!dst.isFUPort()) {
                continue;
            }
            auto& dfu = dst.functionUnit();
            if (&dfu != targetMachine.controlUnit()) {
                continue;
            }
            if (!dst.isOpcodeSetting()) {
                continue;
            }
            if (dst.operation().name() != "JUMP") {
                continue;
            }
 
            int jumpAddr = ins.address().location();
 
            if (src.isInstructionAddress()) {
                int dstAddr = src.value().intValue();
                int diff = dstAddr - jumpAddr;
 
                auto& bus = m.bus();
                if (!bus.signExtends() && diff < 0 && bus.immediateWidth() < 32) {
                    continue;
                }
 
                jumpOffsetMoves[&m] = diff;
                m.setDestination(new TTAProgram::TerminalFUPort(*hwop, 1));
                continue;
            }
 
            if (src.isImmediateRegister()) {
                auto& immu = src.immediateUnit();
                int index = static_cast<int>(src.index());
                bool found = false;
                for (int k = i - immu.latency(); k >= 0 && !found; k--) {
                    auto &immIns = procedure.instructionAtIndex(k);
                    
                    for (int l = 0; l < immIns.immediateCount(); l++) {
                        auto imm = immIns.immediatePtr(l);
                        if (imm->destination().index() == index &&
                            &imm->destination().immediateUnit() == &immu) {
                            int dstAddr = imm->value().value().intValue();
                            int diff = dstAddr - jumpAddr;
 
                            if (!immu.signExtends() && diff < 0 && immu.width() < 32) {
                                found = true;
                                break;
                            }
 
                            jumpOffsetLimms[imm] = diff;
                            m.setDestination(new TTAProgram::TerminalFUPort(*hwop, 1));
                            found = true;
                            break;
                        }
                    }
                    if (irm.hasReference(immIns)) {
                        break;
                    }
                }
            }
        }
    }
 
    // Only update the indeces at the end to keep instr references valid.
    for (auto i : jumpOffsetMoves) {
        i.first->setSource(new TTAProgram::TerminalImmediate(SimValue(i.second, 32)));
    }
 
    for (auto i : jumpOffsetLimms) {
        i.first->setValue(new TTAProgram::TerminalImmediate(SimValue(i.second, 32)));
    }
}

References TTAProgram::Procedure::address(), TTAMachine::Machine::controlUnit(), TTAProgram::Instruction::immediatePtr(), TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Program::instructionReferenceManager(), TTAProgram::Address::location(), and TTAProgram::CodeSnippet::parent().

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

Here is the call graph for this function:

shortDescription()

virtual std::string AbsoluteToRelativeJumps::shortDescription ( ) const

inlineoverridevirtual

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 50 of file AbsoluteToRelativeJumps.hh.

                                                        {
        return "Compiler pass to convert absolute jumps to relative jumps.";
    }

---

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

• AbsoluteToRelativeJumps.hh
• AbsoluteToRelativeJumps.cc