#include <CodeGenerator.hh>

Collaboration diagram for TTAProgram::CodeGenerator:

Public Types
typedef std::set< TCEString >	RegisterSet

Public Member Functions
	CodeGenerator (const TTAMachine::Machine &mach)

virtual	~CodeGenerator ()

TTAProgram::Instruction *	addMoveToProcedure (TTAProgram::CodeSnippet &dstProcedure, TTAProgram::Terminal srcTerminal, TTAProgram::Terminal dstTerminal)

void	addAnnotatedMoveToProcedure (TTAProgram::CodeSnippet &dstProcedure, TTAProgram::Terminal srcTerminal, TTAProgram::Terminal dstTerminal, const TTAProgram::ProgramAnnotation &annotation)

TTAProgram::Terminal *	createTerminalRegister (const TTAMachine::RegisterFile &rf, int regNum, bool readPort) const

TTAProgram::Terminal *	createTerminalRegister (const TCEString &name, bool readPort)

TTAProgram::TerminalFUPort *	createTerminalFUPort (const TCEString &opName, int operand)

void	loadTerminal (TTAProgram::CodeSnippet &dstProcedure, TTAProgram::Terminal srcTerminal, TTAProgram::Terminal dstTerminal)

void	storeTerminal (TTAProgram::CodeSnippet &dstProcedure, TTAProgram::Terminal dstTerminal, TTAProgram::Terminal srcTerminal)

void	loadFromAddress (TTAProgram::CodeSnippet &dstProcedure, TTAProgram::Terminal *srcTerminal, const TCEString &dstReg)

void	storeToAddress (TTAProgram::CodeSnippet &dstProcedure, TTAProgram::Terminal *dstTerminal, const TCEString &srcReg)

void	loadFromRegisterAddress (TTAProgram::CodeSnippet &dstProcedure, const TCEString &srcReg, const TCEString &dstReg)

void	storeToRegisterAddress (TTAProgram::CodeSnippet &dstProcedure, const TCEString &dstReg, const TCEString &srcReg)

void	incrementRegisterAddress (TTAProgram::CodeSnippet &dstProcedure, const TCEString &dstReg, int increment)

void	decrementRegisterAddress (TTAProgram::CodeSnippet &dstProcedure, const TCEString &dstReg, int decrement)

void	incrementStackPointer (TTAProgram::CodeSnippet &dstProcedure, const TCEString &spReg)

void	decrementStackPointer (TTAProgram::CodeSnippet &dstProcedure, const TCEString &spReg)

void	popFromStack (TTAProgram::CodeSnippet &dstProcedure, const TCEString &stackRegister, TTAProgram::Terminal *dstTerminal)

void	popRegisterFromStack (TTAProgram::CodeSnippet &dstProcedure, const TCEString &stackRegister, const TCEString &dstReg)

void	pushToStack (TTAProgram::CodeSnippet &dstProcedure, const TCEString &stackRegister, TTAProgram::Terminal *srcTerminal)

void	pushRegisterToStack (TTAProgram::CodeSnippet &dstProcedure, const TCEString &stackRegister, const TCEString &srcReg)

void	popFromBuffer (TTAProgram::CodeSnippet &dstProcedure, const TCEString &indexRegister, TTAProgram::Terminal *dstTerminal)

void	popRegisterFromBuffer (TTAProgram::CodeSnippet &dstProcedure, const TCEString &indexRegister, const TCEString &dstReg)

void	pushToBuffer (TTAProgram::CodeSnippet &dstProcedure, const TCEString &indexRegister, TTAProgram::Terminal *srcTerminal)

void	pushRegisterToBuffer (TTAProgram::CodeSnippet &dstProcedure, const TCEString &stackRegister, const TCEString &srcReg)

void	pushInstructionReferenceToStack (TTAProgram::CodeSnippet &dstProcedure, const TCEString &stackRegister, TTAProgram::InstructionReference &srcAddr)

void	pushInstructionReferenceToBuffer (TTAProgram::CodeSnippet &dstProcedure, const TCEString &indexRegister, TTAProgram::InstructionReference &srcAddr)

void	registerJump (TTAProgram::CodeSnippet &dstProcedure, const TCEString &jumpAddrReg)

void	registerJump (TTAProgram::CodeSnippet &dstProcedure, const TCEString &jumpAddrReg, const TTAProgram::ProgramAnnotation &annotation)

std::shared_ptr< TTAProgram::Move >	createJump (TTAProgram::InstructionReference &dst)

std::shared_ptr< TTAProgram::Move >	createCall (TTAProgram::InstructionReference &callDst)

void	createExternalCall (TTAProgram::CodeSnippet &dstProcedure, const TCEString &procedureName)

void	createCall (TTAProgram::CodeSnippet &dstProcedure, TTAProgram::InstructionReference &callDst)

void	registerMove (TTAProgram::CodeSnippet &dstProcedure, const TCEString &srcReg, const TCEString &dstReg)

void	immediateMove (TTAProgram::CodeSnippet &dstProcedure, int imm, const TCEString &dstReg)

TTAProgram::Procedure *	createSchedYieldProcedure (TTAProgram::InstructionReferenceManager &refManager, const TCEString &name, const TCEString &schedProcedureName, const TCEString &stackReg, const TCEString &rvReg, const RegisterSet &saveRegs)

std::vector< ProgramOperationPtr >	createForLoopBufferInit (const MoveNode *dynamicLimitMove, int iterationCount, int divider, int loopSize)

ProgramOperationPtr	createBreakOperation (const MoveNode *jump)

ProgramOperationPtr	createWhileLoopBufferInit (int loopSize)

std::shared_ptr< TTAProgram::Move >	createMove (TTAProgram::Terminal src, TTAProgram::Terminal dst)

Static Public Member Functions
static TTAProgram::MoveGuard *	createInverseGuard (const TTAProgram::MoveGuard &mg, const TTAMachine::Bus *bus=NULL)

Private Attributes
const TTAMachine::Machine *	mach_
	Target machine.

const UniversalMachine *	uMach_
	Universal machine.

int	stackAlignment_

MachineInfo::OperationSet	opset_

Detailed Description

CodeGenerator generates code pieces for given Program.

Contains various helper functions for making hand writing of POM easier.

Todo:: Rename to POMGenerator.

Definition at line 53 of file CodeGenerator.hh.

Member Typedef Documentation

◆ RegisterSet

typedef std::set<TCEString> TTAProgram::CodeGenerator::RegisterSet

Definition at line 55 of file CodeGenerator.hh.

Constructor & Destructor Documentation

◆ CodeGenerator()

TTAProgram::CodeGenerator::CodeGenerator ( const TTAMachine::Machine & mach )

Todo:: This should probably take only Program

Definition at line 45 of file CodeGenerator.cc.

    : mach_(&mach), uMach_(&UniversalMachine::instance()) {
    stackAlignment_ = MachineInfo::maxMemoryAlignment(mach);
    opset_ = MachineInfo::getOpset(mach);
}

References MachineInfo::getOpset(), MachineInfo::maxMemoryAlignment(), opset_, and stackAlignment_.

Here is the call graph for this function:

◆ ~CodeGenerator()

TTAProgram::CodeGenerator::~CodeGenerator ( )

virtual

Definition at line 51 of file CodeGenerator.cc.

51{}

Member Function Documentation

◆ addAnnotatedMoveToProcedure()

void TTAProgram::CodeGenerator::addAnnotatedMoveToProcedure	(	TTAProgram::CodeSnippet &	dstProcedure,
		TTAProgram::Terminal *	srcTerminal,
		TTAProgram::Terminal *	dstTerminal,
		const TTAProgram::ProgramAnnotation &	annotation
	)

Definition at line 71 of file CodeGenerator.cc.

                                                   {
 
    TTAProgram::Instruction* newInstr =
        new TTAProgram::Instruction(
            TTAMachine::NullInstructionTemplate::instance());
 
    auto movePtr = std::make_shared<TTAProgram::Move>(
        srcTerminal, dstTerminal, uMach_->universalBus());
 
    movePtr->addAnnotation(annotation);
    newInstr->addMove(movePtr);
 
    dstProcedure.add(newInstr);
}

References TTAProgram::CodeSnippet::add(), TTAProgram::Instruction::addMove(), TTAMachine::NullInstructionTemplate::instance(), uMach_, and UniversalMachine::universalBus().

Referenced by registerJump().

Here is the call graph for this function:

◆ addMoveToProcedure()

TTAProgram::Instruction * TTAProgram::CodeGenerator::addMoveToProcedure	(	TTAProgram::CodeSnippet &	dstProcedure,
		TTAProgram::Terminal *	srcTerminal,
		TTAProgram::Terminal *	dstTerminal
	)

Definition at line 54 of file CodeGenerator.cc.

                                     {
 
    TTAProgram::Instruction* newInstr =
        new TTAProgram::Instruction(
            TTAMachine::NullInstructionTemplate::instance());
 
    newInstr->addMove(std::make_shared<TTAProgram::Move>(
                          srcTerminal, dstTerminal, uMach_->universalBus()));
 
    dstProcedure.add(newInstr);
    return newInstr;
}

References TTAProgram::CodeSnippet::add(), TTAProgram::Instruction::addMove(), TTAMachine::NullInstructionTemplate::instance(), uMach_, and UniversalMachine::universalBus().

Referenced by createCall(), createExternalCall(), decrementRegisterAddress(), llvm::LLVMTCEBuilder::emitLongjmp(), llvm::LLVMTCEBuilder::emitMove(), llvm::LLVMTCEBuilder::emitReadSP(), llvm::LLVMTCEBuilder::emitReturnTo(), llvm::LLVMTCEBuilder::emitSetjmp(), llvm::LLVMTCEBuilder::emitWriteSP(), llvm::LLVMTCEBuilder::handleMemoryCategoryInfo(), immediateMove(), incrementRegisterAddress(), loadTerminal(), registerJump(), registerMove(), and storeTerminal().

Here is the call graph for this function:

◆ createBreakOperation()

ProgramOperationPtr TTAProgram::CodeGenerator::createBreakOperation ( const MoveNode * jump )

Definition at line 1070 of file CodeGenerator.cc.

                                                                            {
    // 4ever loop or buggy input?
    if (jump->move().isUnconditional()) {
        return nullptr;
    }
 
    const TTAMachine::Guard& guard = jump->move().guard().guard();
    auto rg = dynamic_cast<const TTAMachine::RegisterGuard*>(&guard);
    if (!rg) {
        return nullptr;
    }
 
    // TODO: change eq->ne or add xor to support non-inverted without
    // both ops.
    const char* opName = rg->isInverted() ? "lbufc" : "lbufz";
    const TTAMachine::ControlUnit& cu = *mach_->controlUnit();
    if (!cu.hasOperation(opName)) {
        return nullptr;
    }
 
    TTAProgram::TerminalFUPort* dst =
        new TTAProgram::TerminalFUPort(
            *uMach_->universalFunctionUnit().operation(opName), 1);
 
    // create terminal for reading register
    auto src = createTerminalRegister(
        *rg->registerFile(), rg->registerIndex(), true);
 
    MoveNode* loopSizeMN = new MoveNode(createMove(src, dst));
 
    OperationPool pool;
    const Operation& op = pool.operation(opName);
    ProgramOperationPtr po(new ProgramOperation(op));
    po->addInputNode(*loopSizeMN);
    loopSizeMN->addDestinationOperationPtr(po);
    return po;
}

References MoveNode::addDestinationOperationPtr(), TTAMachine::Machine::controlUnit(), createMove(), createTerminalRegister(), TTAProgram::Move::guard(), TTAProgram::MoveGuard::guard(), TTAMachine::FunctionUnit::hasOperation(), TTAMachine::Guard::isInverted(), TTAProgram::Move::isUnconditional(), mach_, MoveNode::move(), UniversalFunctionUnit::operation(), uMach_, and UniversalMachine::universalFunctionUnit().

Here is the call graph for this function:

◆ createCall() [1/2]

void TTAProgram::CodeGenerator::createCall	(	TTAProgram::CodeSnippet &	dstProcedure,
		TTAProgram::InstructionReference &	callDst
	)

Creates a call move and adds it to the given procedure.

Definition at line 689 of file CodeGenerator.cc.

                                             {
 
    TTAProgram::TerminalInstructionReference* srcTerminal =
        new TTAProgram::TerminalInstructionReference(callDst);
 
    TTAProgram::TerminalFUPort* dstTerminal =
        createTerminalFUPort("call", 1);
 
    addMoveToProcedure(dstProcedure, srcTerminal, dstTerminal);
}

References addMoveToProcedure(), and createTerminalFUPort().

Here is the call graph for this function:

◆ createCall() [2/2]

std::shared_ptr< TTAProgram::Move > TTAProgram::CodeGenerator::createCall ( TTAProgram::InstructionReference & callDst )

Creates a call move.

Definition at line 657 of file CodeGenerator.cc.

                                                                 {
    TTAProgram::TerminalInstructionReference* srcTerminal =
        new TTAProgram::TerminalInstructionReference(callDst);
 
    TTAProgram::TerminalFUPort* dstTerminal =
        createTerminalFUPort("call", 1);
    return std::make_shared<TTAProgram::Move>(
        srcTerminal, dstTerminal, uMach_->universalBus());
}

References createTerminalFUPort(), uMach_, and UniversalMachine::universalBus().

Here is the call graph for this function:

◆ createExternalCall()

void TTAProgram::CodeGenerator::createExternalCall	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	procedureName
	)

Creates an external call move.

Definition at line 671 of file CodeGenerator.cc.

                                    {
 
    TTAProgram::TerminalSymbolReference* srcTerminal =
        new TTAProgram::TerminalSymbolReference(procedureName);
 
    TTAProgram::TerminalFUPort* dstTerminal =
        createTerminalFUPort("call", 1);
 
    addMoveToProcedure(dstProcedure, srcTerminal, dstTerminal);
}

References addMoveToProcedure(), and createTerminalFUPort().

Referenced by createSchedYieldProcedure().

Here is the call graph for this function:

◆ createForLoopBufferInit()

std::vector< ProgramOperationPtr > TTAProgram::CodeGenerator::createForLoopBufferInit	(	const MoveNode *	dynamicLimitMove,
		int	iterationCount,
		int	divider,
		int	loopSize
	)

Definition at line 898 of file CodeGenerator.cc.

                                                                                     {
 
    std::vector<ProgramOperationPtr> res;
    // is power-of-2?
    if (divider & (divider-1)) {
        return res;
    }
 
    const char* opName = "lbufs";
    const TTAMachine::ControlUnit& cu = *mach_->controlUnit();
    if (!cu.hasOperation(opName)) {
        return res;
    }
 
    OperationPool pool;
    const Operation& lbufsOp = pool.operation(opName);
    SimValue loopSizeSV(MathTools::requiredBitsSigned(loopSize));
    loopSizeSV = loopSize;
    TTAProgram::TerminalImmediate* loopSizeSrc =
        new TTAProgram::TerminalImmediate(loopSizeSV);
 
    MoveNode* iterCountMN = NULL;
    ProgramOperationPtr shiftPO;
    ProgramOperationPtr subPO;
 
    // TODO: universalmachine is buggy. these should be in control unit,
    // not universalfunction unit
    TTAProgram::TerminalFUPort* iterCountDst =
        new TTAProgram::TerminalFUPort(
            *uMach_->universalFunctionUnit().operation(opName), 1);
 
    TTAProgram::TerminalFUPort* loopSizeDst =
        new TTAProgram::TerminalFUPort(
            *uMach_->universalFunctionUnit().operation(opName), 2);
 
    // static iteration count
    if (dynamicLimitMove == NULL) {
        SimValue iterCountSV(MathTools::requiredBitsSigned(iterationCount)); 
        iterCountSV = iterationCount;
        TTAProgram::Terminal* iterCountSrc = new TTAProgram::TerminalImmediate(iterCountSV);
        iterCountMN = new MoveNode(createMove(iterCountSrc, iterCountDst));
    } else {
        bool decrement = false;
        bool increment = false;
        switch (iterationCount) {
        case -1:
            decrement = true;
        case 0:
            break;
        default:
            if (iterationCount > 0)
                increment = true;
            else
                return res;
        }
        TTAProgram::Terminal* counterValSrc = NULL;
        if (dynamicLimitMove->isSourceOperation())
            counterValSrc = dynamicLimitMove->move().destination().copy();
        else
            counterValSrc = dynamicLimitMove->move().source().copy();
 
        // if divider not 1, need shift of to scale it down.
        TCEString adjustName = decrement ? "sub" : "add";
        if (mach_->is64bit()) {
            adjustName << "64";
        }
        if (decrement || increment) {
            const Operation& subOp = pool.operation(adjustName.c_str());
            subPO = std::make_shared<ProgramOperation>(subOp);
 
            // signed 1 is 2 bits.
            TTAProgram::TerminalImmediate* subAmountSrc =
                new TTAProgram::TerminalImmediate(
                    SimValue(abs(iterationCount),
                             MathTools::requiredBitsSigned(iterationCount)));
 
            TTAProgram::TerminalFUPort* subAmntDst = createTerminalFUPort(adjustName, 2);
            TTAProgram::TerminalFUPort* subRes = createTerminalFUPort(adjustName, 3);
 
            MoveNode* subAmtMN = new MoveNode(createMove(subAmountSrc, subAmntDst));
            subPO->addInputNode(*subAmtMN);
            subAmtMN->addDestinationOperationPtr(subPO);
 
            iterCountMN = new MoveNode(createMove(subRes, iterCountDst));
            subPO->addOutputNode(*iterCountMN);
            iterCountMN->setSourceOperationPtr(subPO);
 
            res.push_back(subPO);
            // first input not here but later
        }
 
        if (divider > 1) {
            TCEString shiftName = "shr";
            if (mach_->is64bit()) {
                shiftName << "64";
            }
            const Operation& shiftOp = pool.operation(shiftName.c_str());
 
            int shiftAmount = MathTools::ceil_log2(divider);
 
            SimValue shiftAmountSV(MathTools::requiredBitsSigned(shiftAmount));
            shiftAmountSV = shiftAmount;
 
            TTAProgram::TerminalImmediate* shiftAmountSrc =
                new TTAProgram::TerminalImmediate(shiftAmountSV);
 
            // create terminal references
            TTAProgram::TerminalFUPort* shiftValDst =
                createTerminalFUPort(shiftName, 1);
            TTAProgram::TerminalFUPort* shiftAmntDst =
                createTerminalFUPort(shiftName, 2);
            TTAProgram::TerminalFUPort* shiftRes =
                createTerminalFUPort(shiftName, 3);
 
            MoveNode* shiftValMN = new MoveNode(createMove(counterValSrc, shiftValDst));
            MoveNode* shiftAmtMN = new MoveNode(createMove(shiftAmountSrc, shiftAmntDst));
 
            shiftPO = std::make_shared<ProgramOperation>(shiftOp);
            shiftPO->addInputNode(*shiftValMN);
            shiftPO->addInputNode(*shiftAmtMN);
            shiftValMN->addDestinationOperationPtr(shiftPO);
            shiftAmtMN->addDestinationOperationPtr(shiftPO);
 
            // push before the possible sub
            res.insert(res.begin(),shiftPO);
            MoveNode* shift2dec = NULL;
            if (!(decrement||increment)) {
                iterCountMN = new MoveNode(createMove(shiftRes, iterCountDst));
                shiftPO->addOutputNode(*iterCountMN);
                iterCountMN->setSourceOperationPtr(shiftPO);
            } else {
                // use dsub operation
                TTAProgram::TerminalFUPort* subValDst =
                    createTerminalFUPort(adjustName, 1);
                shift2dec = new MoveNode(createMove(shiftRes, subValDst));
                subPO->addInputNode(*shift2dec);
                shift2dec->addDestinationOperationPtr(subPO);
 
                shiftPO->addOutputNode(*shift2dec);
                shift2dec->setSourceOperationPtr(shiftPO);
            }
        } else { // no shifting, maybe decrement
            if (decrement||increment) {
                // create terminal references
                TTAProgram::TerminalFUPort* subValDst =
                    createTerminalFUPort(adjustName, 1);
                MoveNode* subValMN = new MoveNode(createMove(counterValSrc, subValDst));
                subPO->addInputNode(*subValMN);
                subValMN->addDestinationOperationPtr(subPO);
            } else {
                iterCountMN = new MoveNode(createMove(counterValSrc, iterCountDst));
            }
        }
    }
    MoveNode* loopSizeMN = new MoveNode(createMove(loopSizeSrc, loopSizeDst));
 
    ProgramOperationPtr loopBusInitOp(new ProgramOperation(lbufsOp));
    loopBusInitOp->addInputNode(*iterCountMN);
    loopBusInitOp->addInputNode(*loopSizeMN);
    iterCountMN->addDestinationOperationPtr(loopBusInitOp);
    loopSizeMN->addDestinationOperationPtr(loopBusInitOp);
 
    res.push_back(loopBusInitOp);
    return res;
}

References MoveNode::addDestinationOperationPtr(), MathTools::ceil_log2(), TTAMachine::Machine::controlUnit(), TTAProgram::Terminal::copy(), createMove(), createTerminalFUPort(), TTAProgram::Move::destination(), TTAMachine::FunctionUnit::hasOperation(), TTAMachine::Machine::is64bit(), MoveNode::isSourceOperation(), mach_, MoveNode::move(), UniversalFunctionUnit::operation(), MathTools::requiredBitsSigned(), MoveNode::setSourceOperationPtr(), TTAProgram::Move::source(), uMach_, and UniversalMachine::universalFunctionUnit().

Here is the call graph for this function:

◆ createInverseGuard()

TTAProgram::MoveGuard * TTAProgram::CodeGenerator::createInverseGuard	(	const TTAProgram::MoveGuard &	mg,
		const TTAMachine::Bus *	bus = `NULL`
	)

static

Creates a guard with same guard register etc but inverted. The guard must be found from the given bus if bus given.

@TODO: support for port guards

Parameters

mg	guard to inverse
bus	bus where the guard must be. if null same as bug of mg.

Returns: new MoveGuard that is given guard inverted, NULL if cannot create.

Definition at line 837 of file CodeGenerator.cc.

                                                             {
 
    const TTAMachine::Guard& g = mg.guard();
    if (bus == NULL) {
        bus = g.parentBus();
    }
 
    bool inv = g.isInverted();
    const TTAMachine::RegisterGuard* rg =
        dynamic_cast<const TTAMachine::RegisterGuard*>(&g);
    if (rg != NULL) {
        const TTAMachine::RegisterFile* rf = rg->registerFile();
        int regIndex = rg->registerIndex();
 
        // fake guard to be bypassed as port guard?
        if (bus == nullptr) {
            return new TTAProgram::MoveGuard(
                *new TTAMachine::RegisterGuard(
                    !rg->isInverted(), *rg->registerFile(), rg->registerIndex(), nullptr));
        }
        // find guard
        for (int i = 0 ; i < bus->guardCount(); i++) {
            const TTAMachine::Guard *g2 = bus->guard(i);
            const TTAMachine::RegisterGuard* rg2 =
                dynamic_cast<const TTAMachine::RegisterGuard*>(g2);
            if (rg2) {
                if( rg2->registerFile() == rf &&
                    rg2->registerIndex() == regIndex &&
                    rg2->isInverted() == !inv ) {
                    return new TTAProgram::MoveGuard(*rg2);
                }
            }
        }
    }
    const TTAMachine::PortGuard* pg =
        dynamic_cast<const TTAMachine::PortGuard*>(&g);
    if (pg) {
        auto port = pg->port();
 
        // find guard
        for (int i = 0 ; i < bus->guardCount(); i++) {
            const TTAMachine::Guard *g2 = bus->guard(i);
            const TTAMachine::PortGuard* pg2 =
                dynamic_cast<const TTAMachine::PortGuard*>(g2);
            if (pg2 && pg2->port() == port &&
                pg2->isInverted() == !inv) {
                return new TTAProgram::MoveGuard(*pg2);
            }
        }
    }
 
    return NULL;
}

References TTAProgram::MoveGuard::guard(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), TTAMachine::Guard::isInverted(), TTAMachine::Guard::parentBus(), TTAMachine::PortGuard::port(), TTAMachine::RegisterGuard::registerFile(), and TTAMachine::RegisterGuard::registerIndex().

Referenced by Peel2BBLoops::appendBB(), SimpleIfConverter::canConvert(), CopyingDelaySlotFiller::collectMoves(), CopyingDelaySlotFiller::fillDelaySlots(), PreOptimizer::inverseGuardsOfHeads(), BasicBlockScheduler::tryToOptimizeWaw(), and BUBasicBlockScheduler::tryToOptimizeWaw().

Here is the call graph for this function:

◆ createJump()

std::shared_ptr< TTAProgram::Move > TTAProgram::CodeGenerator::createJump ( TTAProgram::InstructionReference & dst )

Definition at line 640 of file CodeGenerator.cc.

                                                             {
 
    TTAProgram::TerminalFUPort* jump1Terminal =
        createTerminalFUPort("jump", 1);
 
    TTAProgram::Terminal* jump0Terminal =
        new TTAProgram::TerminalInstructionReference(dst);
 
    return std::make_shared<TTAProgram::Move>(jump0Terminal, jump1Terminal,
                                         uMach_->universalBus());
}

References createTerminalFUPort(), uMach_, and UniversalMachine::universalBus().

Referenced by SimpleIfConverter::addJump().

Here is the call graph for this function:

◆ createMove()

std::shared_ptr< TTAProgram::Move > TTAProgram::CodeGenerator::createMove	(	TTAProgram::Terminal *	src,
		TTAProgram::Terminal *	dst
	)

Definition at line 1065 of file CodeGenerator.cc.

                                                      {
    return std::make_shared<TTAProgram::Move>(src, dst, uMach_->universalBus());
}

References uMach_, and UniversalMachine::universalBus().

Referenced by createBreakOperation(), createForLoopBufferInit(), and createWhileLoopBufferInit().

Here is the call graph for this function:

◆ createSchedYieldProcedure()

TTAProgram::Procedure * TTAProgram::CodeGenerator::createSchedYieldProcedure	(	TTAProgram::InstructionReferenceManager &	refManager,
		const TCEString &	name,
		const TCEString &	schedProcedureName,
		const TCEString &	stackReg,
		const TCEString &	rvReg,
		const RegisterSet &	saveRegs
	)

Creates yield function which saves requested registers.

Parameters

refManager	Reference manager of destination program.
name	Name for the created procedure.
schedProcedure	Scheduler function to call sp = schedule(sp)
stackReg	Stack register name assigned for program.
rvReg	Return value register name.
saveRegs	Set of registers, which should be saved.

Definition at line 743 of file CodeGenerator.cc.

                                 {
 
    TTAProgram::Procedure* retVal =
        new TTAProgram::Procedure(
            name, *mach_->controlUnit()->addressSpace());
 
    // *** Push registers to stack
    for(RegisterSet::const_iterator i = saveRegs.begin();
        i != saveRegs.end(); i++) {
        pushRegisterToStack(*retVal, stackReg, *i);
    }
 
    // *** Push return address to stack as well
    pushRegisterToStack(*retVal, stackReg, "RA");
 
    // *** Create empty instruction to be used as yield_return destination
    TTAProgram::Instruction* yeldReturnInstruction =
        new TTAProgram::Instruction(
            TTAMachine::NullInstructionTemplate::instance());
 
    TTAProgram::InstructionReference yeldReturnReference =
        refManager.createReference(*yeldReturnInstruction);
 
    // *** Push InstructionReference to sp reading instruction to stack
    pushInstructionReferenceToStack(*retVal, stackReg, yeldReturnReference);
 
    // *** Save sp, switch thread and update sp
 
    // put stackpointer address to be parameter
#ifdef ALL_STACK_PARAMETERS
    pushRegisterToStack(*retVal, stackReg, stackReg);
#else
    registerMove(*retVal, stackReg, rvReg);
#endif
    createExternalCall(*retVal, schedProcedureName);
 
    // read new sp value from rv register
    registerMove(*retVal, rvReg, stackReg);
 
#ifdef ALL_STACK_PARAMETERS
    // need to pop the parameter from stack
    incrementStackPointer(*retVal, stackReg);
#endif
 
    // read yeld address from stack
    popRegisterFromStack(*retVal, stackReg, "RA");
 
    // jump to yeld point
    registerJump(*retVal, "RA", TTAProgram::ProgramAnnotation(
                     TTAProgram::ProgramAnnotation::ANN_JUMP_TO_NEXT));
 
    // add previously created "label" instruction
    retVal->add(yeldReturnInstruction);
 
    // restore return address
    popRegisterFromStack(*retVal, stackReg, "RA");
 
    // read registers from stack
    for(RegisterSet::const_reverse_iterator i = saveRegs.rbegin();
        i != saveRegs.rend(); i++) {
        popRegisterFromStack(*retVal, stackReg, *i);
    }
 
    // jump to yeld point
    registerJump(*retVal, "RA");
 
    // remove the placeholder instr.
    refManager.replace(
        *yeldReturnInstruction, 
        retVal->nextInstruction(*yeldReturnInstruction));
 
    retVal->remove(*yeldReturnInstruction);
    // debug print created function
 
    return retVal;
}

References TTAProgram::Procedure::add(), TTAMachine::FunctionUnit::addressSpace(), TTAProgram::ProgramAnnotation::ANN_JUMP_TO_NEXT, TTAMachine::Machine::controlUnit(), createExternalCall(), TTAProgram::InstructionReferenceManager::createReference(), incrementStackPointer(), TTAMachine::NullInstructionTemplate::instance(), mach_, TTAProgram::CodeSnippet::nextInstruction(), popRegisterFromStack(), pushInstructionReferenceToStack(), pushRegisterToStack(), registerJump(), registerMove(), TTAProgram::Procedure::remove(), and TTAProgram::InstructionReferenceManager::replace().

Here is the call graph for this function:

◆ createTerminalFUPort()

TTAProgram::TerminalFUPort * TTAProgram::CodeGenerator::createTerminalFUPort	(	const TCEString &	opName,
		int	operand = `0`
	)

If operand is not given return return address terminal.

Definition at line 94 of file CodeGenerator.cc.

                                                                            {
    if (operand != 0) {
 
        OperationPool pool;
        const Operation& op = pool.operation(opName.c_str());
        if (op.isControlFlowOperation()) {
            TTAMachine::HWOperation& hwOp =
                *uMach_->controlUnit()->operation(opName);
            return new TTAProgram::TerminalFUPort(hwOp, operand);
        } else {
            TTAMachine::HWOperation& hwOp =
                *uMach_->universalFunctionUnit().operation(opName);
            return new TTAProgram::TerminalFUPort(hwOp, operand);
        }
    } else {
        return new TTAProgram::TerminalFUPort(
            *uMach_->controlUnit()->returnAddressPort());
    }
}

References TTAMachine::Machine::controlUnit(), Operation::isControlFlowOperation(), TTAMachine::FunctionUnit::operation(), UniversalFunctionUnit::operation(), TTAMachine::ControlUnit::returnAddressPort(), uMach_, and UniversalMachine::universalFunctionUnit().

Referenced by createCall(), createCall(), createExternalCall(), createForLoopBufferInit(), createJump(), createTerminalRegister(), decrementRegisterAddress(), llvm::LLVMTCEBuilder::emitGlobalXXtructorCalls(), CallsToJumps::handleControlFlowGraph(), incrementRegisterAddress(), loadTerminal(), registerJump(), registerJump(), BFCopyRegWithOp::splitMove(), and storeTerminal().

Here is the call graph for this function:

◆ createTerminalRegister() [1/2]

TTAProgram::Terminal * TTAProgram::CodeGenerator::createTerminalRegister	(	const TCEString &	name,
		bool	readPort
	)

Definition at line 135 of file CodeGenerator.cc.

                                                                          {
 
    if (name == "RA") {
        return createTerminalFUPort("RA");
    } else {
        const TTAMachine::RegisterFile* rf = NULL;
        size_t findResult = name.find(".");
        int regNum;
        if (findResult == std::string::npos) {
            rf = &uMach_->integerRegisterFile();
            regNum = Conversion::toInt(name.substr(1));
 
        }  else {
            TCEString rfName = name.substr(0, findResult);
            TTAMachine::Machine::RegisterFileNavigator regNav =
                mach_->registerFileNavigator();
            rf = regNav.item(rfName);
            regNum = Conversion::toInt(
            name.substr(findResult + 1, name.length()-findResult+1));
        }
        return createTerminalRegister(*rf, regNum, readPort);
    }
 
    return NULL;
}

References createTerminalFUPort(), createTerminalRegister(), UniversalMachine::integerRegisterFile(), TTAMachine::Machine::Navigator< ComponentType >::item(), mach_, TTAMachine::Machine::registerFileNavigator(), Conversion::toInt(), and uMach_.

Here is the call graph for this function:

◆ createTerminalRegister() [2/2]

TTAProgram::Terminal * TTAProgram::CodeGenerator::createTerminalRegister	(	const TTAMachine::RegisterFile &	rf,
		int	regNum,
		bool	readPort
	)		const

Definition at line 115 of file CodeGenerator.cc.

                                                                       {
    for (int i = 0; i < rf.portCount(); i++) {
        if (readPort) {
            if (rf.port(i)->isOutput()) {
                return new TTAProgram::TerminalRegister(
                    *rf.port(i), regNum);
            }
        } else {
            if (rf.port(i)->isInput()) {
                return new TTAProgram::TerminalRegister(
                    *rf.port(i), regNum);
            }
        }
    }
    return NULL;
}

References TTAMachine::Port::isInput(), TTAMachine::Port::isOutput(), TTAMachine::BaseRegisterFile::port(), and TTAMachine::Unit::portCount().

Referenced by createBreakOperation(), createTerminalRegister(), decrementRegisterAddress(), llvm::LLVMTCEBuilder::emitLongjmp(), llvm::LLVMTCEBuilder::emitReadSP(), llvm::LLVMTCEBuilder::emitReturnTo(), llvm::LLVMTCEBuilder::emitSetjmp(), llvm::LLVMTCEBuilder::emitWriteSP(), immediateMove(), incrementRegisterAddress(), loadFromAddress(), loadFromRegisterAddress(), popFromBuffer(), popFromStack(), pushToBuffer(), pushToStack(), registerJump(), registerJump(), registerMove(), storeToAddress(), and storeToRegisterAddress().

Here is the call graph for this function:

◆ createWhileLoopBufferInit()

ProgramOperationPtr TTAProgram::CodeGenerator::createWhileLoopBufferInit ( int loopSize )

Definition at line 1116 of file CodeGenerator.cc.

                                                     {
    const char* opName = "infloop";
    const TTAMachine::ControlUnit& cu = *mach_->controlUnit();
    if (!cu.hasOperation(opName)) {
        return nullptr;
    }
 
    TTAProgram::TerminalFUPort* loopSizeDst =
        new TTAProgram::TerminalFUPort(
            *uMach_->universalFunctionUnit().operation(opName), 1);
 
    OperationPool pool;
    const Operation& lbufsOp = pool.operation(opName);
    SimValue loopSizeSV(MathTools::requiredBitsSigned(loopSize));
    loopSizeSV = loopSize;
    TTAProgram::TerminalImmediate* loopSizeSrc =
        new TTAProgram::TerminalImmediate(loopSizeSV);
 
    MoveNode* loopSizeMN = new MoveNode(createMove(loopSizeSrc, loopSizeDst));
 
    ProgramOperationPtr loopBufInitOp(new ProgramOperation(lbufsOp));
    loopBufInitOp->addInputNode(*loopSizeMN);
    loopSizeMN->addDestinationOperationPtr(loopBufInitOp);
    return loopBufInitOp;
}

References MoveNode::addDestinationOperationPtr(), TTAMachine::Machine::controlUnit(), createMove(), TTAMachine::FunctionUnit::hasOperation(), mach_, UniversalFunctionUnit::operation(), MathTools::requiredBitsSigned(), uMach_, and UniversalMachine::universalFunctionUnit().

Here is the call graph for this function:

◆ decrementRegisterAddress()

void TTAProgram::CodeGenerator::decrementRegisterAddress	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	dstReg,
		int	decrement
	)

Decrement address in a register by value of decrement.

Parameters

dstProcedure	Procedure to add the moves to.
dstReg	Register to decrement.
decrement	How much to decrement.

Definition at line 380 of file CodeGenerator.cc.

                   {
 
    TCEString subOp = mach_->is64bit() ? "sub64" : "sub";
 
    // create terminal references
    TTAProgram::Terminal* regReadTerminal =
        createTerminalRegister(dstReg, true);
 
    TTAProgram::Terminal* regWriteTerminal =
        createTerminalRegister(dstReg, false);
 
    // TODO: immediate creator function which calculates immWidth
    SimValue immVal(MathTools::requiredBitsSigned(decrement));
    immVal = decrement;
    TTAProgram::TerminalImmediate* imm4Terminal =
        new TTAProgram::TerminalImmediate(immVal);
 
    TTAProgram::TerminalFUPort* sub1Terminal =
        createTerminalFUPort(subOp, 1);
 
    TTAProgram::TerminalFUPort* sub2Terminal =
        createTerminalFUPort(subOp, 2);
 
    TTAProgram::TerminalFUPort* sub3Terminal =
        createTerminalFUPort(subOp, 3);
 
    // dstProcedure->add(
    //      new CodeSnippet("sp -> sub.1; 4 -> sub.2; sub.3 -> sp;"
    //                      "sp -> stw.1; srcTerm -> stw.2;"));
    addMoveToProcedure(dstProcedure, regReadTerminal, sub1Terminal);
    addMoveToProcedure(dstProcedure, imm4Terminal, sub2Terminal);
    addMoveToProcedure(dstProcedure, sub3Terminal, regWriteTerminal);
}

References addMoveToProcedure(), createTerminalFUPort(), createTerminalRegister(), TTAMachine::Machine::is64bit(), mach_, and MathTools::requiredBitsSigned().

Referenced by decrementStackPointer(), popFromBuffer(), and popRegisterFromBuffer().

Here is the call graph for this function:

◆ decrementStackPointer()

void TTAProgram::CodeGenerator::decrementStackPointer	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	spReg
	)

Definition at line 423 of file CodeGenerator.cc.

                                                                 {
    decrementRegisterAddress(dstProcedure, spReg, stackAlignment_);
}

References decrementRegisterAddress(), and stackAlignment_.

Referenced by llvm::LLVMTCEBuilder::emitSetjmp(), pushRegisterToStack(), and pushToStack().

Here is the call graph for this function:

◆ immediateMove()

void TTAProgram::CodeGenerator::immediateMove	(	TTAProgram::CodeSnippet &	dstProcedure,
		int	imm,
		const TCEString &	dstReg
	)

Definition at line 717 of file CodeGenerator.cc.

                                      {
 
    SimValue immVal(32);
    immVal = imm;
    TTAProgram::TerminalImmediate* srcTerminal =
        new TTAProgram::TerminalImmediate(immVal);
 
    TTAProgram::Terminal* dstTerminal =
        createTerminalRegister(dstReg, false);
 
    addMoveToProcedure(dstProcedure, srcTerminal, dstTerminal);
}

References addMoveToProcedure(), and createTerminalRegister().

Here is the call graph for this function:

◆ incrementRegisterAddress()

void TTAProgram::CodeGenerator::incrementRegisterAddress	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	dstReg,
		int	increment
	)

Increment address in a register by value of increment.

Parameters

dstProcedure	Procedure to add the moves to.
dstReg	Register to increment.
increment	How much to increment.

Definition at line 335 of file CodeGenerator.cc.

                   {
 
    TCEString addOp = mach_->is64bit() ? "add64" : "add";
 
    // create terminal references
    TTAProgram::Terminal* regReadTerminal =
        createTerminalRegister(dstReg, true);
 
    TTAProgram::Terminal* regWriteTerminal =
        createTerminalRegister(dstReg, false);
 
    // TODO: immediate creator function which calculates immWidth
    SimValue immVal(MathTools::requiredBitsSigned(increment));
    immVal = increment;
    TTAProgram::TerminalImmediate* imm4Terminal =
        new TTAProgram::TerminalImmediate(immVal);
 
    TTAProgram::TerminalFUPort* add1Terminal =
        createTerminalFUPort(addOp, 1);
 
    TTAProgram::TerminalFUPort* add2Terminal =
        createTerminalFUPort(addOp, 2);
 
    TTAProgram::TerminalFUPort* add3Terminal =
        createTerminalFUPort(addOp, 3);
 
    // dstProcedure->add(
    //      new CodeSnippet("sp -> ldw.1; ldw.2 -> dstReg; "
    //                      "4 -> add.1; sp -> add.2; add.3 -> sp"));
 
    addMoveToProcedure(dstProcedure, imm4Terminal, add1Terminal);
    addMoveToProcedure(dstProcedure, regReadTerminal, add2Terminal);
    addMoveToProcedure(dstProcedure, add3Terminal, regWriteTerminal);
}

References addMoveToProcedure(), createTerminalFUPort(), createTerminalRegister(), TTAMachine::Machine::is64bit(), mach_, and MathTools::requiredBitsSigned().

Referenced by incrementStackPointer(), pushRegisterToBuffer(), and pushToBuffer().

Here is the call graph for this function:

◆ incrementStackPointer()

void TTAProgram::CodeGenerator::incrementStackPointer	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	spReg
	)

Definition at line 417 of file CodeGenerator.cc.

                                                                 {
    incrementRegisterAddress(dstProcedure, spReg, stackAlignment_);
}

References incrementRegisterAddress(), and stackAlignment_.

Referenced by createSchedYieldProcedure(), llvm::LLVMTCEBuilder::emitLongjmp(), llvm::LLVMTCEBuilder::emitSetjmp(), popFromStack(), and popRegisterFromStack().

Here is the call graph for this function:

◆ loadFromAddress()

void TTAProgram::CodeGenerator::loadFromAddress	(	TTAProgram::CodeSnippet &	dstProcedure,
		TTAProgram::Terminal *	srcTerminal,
		const TCEString &	dstReg
	)

Loads register from address in a terminal.

Parameters

dstProcedure	Procedure to add the moves to.
srcTerminal	Address to load from.
dstReg	Register to store loaded value.

Definition at line 256 of file CodeGenerator.cc.

                             {
 
    // create terminal references
    TTAProgram::Terminal* dstRegTerminal =
        createTerminalRegister(dstReg, false);
 
    loadTerminal(dstProcedure, srcTerminal, dstRegTerminal);
}

References createTerminalRegister(), and loadTerminal().

Referenced by loadFromRegisterAddress().

Here is the call graph for this function:

◆ loadFromRegisterAddress()

void TTAProgram::CodeGenerator::loadFromRegisterAddress	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	srcReg,
		const TCEString &	dstReg
	)

Loads register from address in another register.

Parameters

dstProcedure	Procedure to add the moves to.
srcReg	Address to load from.
dstReg	Register to store loaded value.

Definition at line 295 of file CodeGenerator.cc.

                             {
 
    // create terminal references
    TTAProgram::Terminal* srcTerminal =
        createTerminalRegister(srcReg, true);
 
    loadFromAddress(dstProcedure, srcTerminal, dstReg);
}

References createTerminalRegister(), and loadFromAddress().

Referenced by llvm::LLVMTCEBuilder::emitLongjmp(), popRegisterFromBuffer(), and popRegisterFromStack().

Here is the call graph for this function:

◆ loadTerminal()

void TTAProgram::CodeGenerator::loadTerminal	(	TTAProgram::CodeSnippet &	dstProcedure,
		TTAProgram::Terminal *	srcTerminal,
		TTAProgram::Terminal *	dstTerminal
	)

Loads terminal from address in a terminal.

Parameters

dstProcedure	Procedure to add the moves to.
srcTerminal	Address to load from.
dstTerminal	Terminal to store loaded value.

Definition at line 169 of file CodeGenerator.cc.

                                     {
    TCEString loadOp;
    int width = 0;
    if (dstTerminal->isGPR()) {
        width = dstTerminal->registerFile().width();
    }
 
    int defaultWidth = mach_->is64bit() ? 64 : 32;
    if (width < defaultWidth) {
        width = defaultWidth;
    }
    if (mach_->isLittleEndian()) {
        loadOp = (boost::format("ld%d") % width).str();
    } else {
        loadOp = "ldw";
    }
    if (opset_.count(loadOp) == 0) {
        abortWithError(
            (boost::format("Operation %s not found in the machine") % loadOp)
                .str());
    }
 
    // create terminal references
    TTAProgram::TerminalFUPort* load1Terminal =
        createTerminalFUPort(loadOp, 1);
 
    TTAProgram::TerminalFUPort* load2Terminal =
        createTerminalFUPort(loadOp, 2);
 
    addMoveToProcedure(dstProcedure, srcTerminal, load1Terminal);
    addMoveToProcedure(dstProcedure, load2Terminal, dstTerminal);
}

References abortWithError, addMoveToProcedure(), createTerminalFUPort(), TTAMachine::Machine::is64bit(), TTAProgram::Terminal::isGPR(), TTAMachine::Machine::isLittleEndian(), mach_, opset_, TTAProgram::Terminal::registerFile(), and TTAMachine::BaseRegisterFile::width().

Referenced by llvm::LLVMTCEBuilder::createSPInitLoad(), loadFromAddress(), popFromBuffer(), and popFromStack().

Here is the call graph for this function:

◆ popFromBuffer()

void TTAProgram::CodeGenerator::popFromBuffer	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	indexRegister,
		TTAProgram::Terminal *	dstTerminal
	)

TODO Decide how much the register value should be incremented in the following buffer operations. Right now it's 4, but maybe it should be calculated based on the terminal size. These operations aren't currently used anywhere. For stack buffer operations you should use the above functions, since they take into account the stack alignment. Pops value from buffer and stores it in a given terminal.

Parameters

dstProcedure	Procedure to add the moves to.
indexRegister	Pointer to the buffer.
dstTerminal	Terminal to put the value into.

Definition at line 529 of file CodeGenerator.cc.

                                     {
    decrementRegisterAddress(dstProcedure, indexRegister, 4);
 
    TTAProgram::Terminal* indexTerminal =
        createTerminalRegister(indexRegister, true);
    loadTerminal(dstProcedure, indexTerminal, dstTerminal);
}

References createTerminalRegister(), decrementRegisterAddress(), and loadTerminal().

Here is the call graph for this function:

◆ popFromStack()

void TTAProgram::CodeGenerator::popFromStack	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	stackRegister,
		TTAProgram::Terminal *	dstTerminal
	)

Pops value from stack and stores it in a given terminal.

Parameters

dstProcedure	Procedure to add the moves to.
stackRegister	Stack pointer name.
dstTerminal	Terminal to put the value into.

Definition at line 436 of file CodeGenerator.cc.

                                     {
 
    TTAProgram::Terminal* stackTerminal =
        createTerminalRegister(stackRegister, true);
    loadTerminal(dstProcedure, stackTerminal, dstTerminal);
 
    incrementStackPointer(dstProcedure, stackRegister);
}

References createTerminalRegister(), incrementStackPointer(), and loadTerminal().

Referenced by llvm::LLVMTCEBuilder::emitSetjmp().

Here is the call graph for this function:

◆ popRegisterFromBuffer()

void TTAProgram::CodeGenerator::popRegisterFromBuffer	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	indexRegister,
		const TCEString &	dstReg
	)

Pops value from buffer and stores it in a register.

Parameters

dstProcedure	Procedure to add the moves to.
indexRegister	Pointer to the buffer.
dstReg	Register to put the value into.

Definition at line 548 of file CodeGenerator.cc.

                             {
    decrementRegisterAddress(dstProcedure, indexRegister, 4);
 
    loadFromRegisterAddress(dstProcedure, indexRegister, dstReg);
}

References decrementRegisterAddress(), and loadFromRegisterAddress().

Here is the call graph for this function:

◆ popRegisterFromStack()

void TTAProgram::CodeGenerator::popRegisterFromStack	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	stackRegister,
		const TCEString &	dstReg
	)

Pops value from stack and stores it in a register.

Parameters

dstProcedure	Procedure to add the moves to.
stackRegister	Stack pointer name.
dstReg	Register to put the value into.

Definition at line 456 of file CodeGenerator.cc.

                             {
 
    loadFromRegisterAddress(dstProcedure, stackRegister, dstReg);
 
    incrementStackPointer(dstProcedure, stackRegister);
}

References incrementStackPointer(), and loadFromRegisterAddress().

Referenced by createSchedYieldProcedure(), llvm::LLVMTCEBuilder::emitLongjmp(), and llvm::LLVMTCEBuilder::emitSetjmp().

Here is the call graph for this function:

◆ pushInstructionReferenceToBuffer()

void TTAProgram::CodeGenerator::pushInstructionReferenceToBuffer	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	indexRegister,
		TTAProgram::InstructionReference &	srcAddr
	)

Definition at line 596 of file CodeGenerator.cc.

                                             {
 
    // create terminal references
    TTAProgram::TerminalInstructionReference* srcTerminal =
        new TTAProgram::TerminalInstructionReference(srcAddr);
 
    pushToBuffer(dstProcedure, indexRegister, srcTerminal);
}

References pushToBuffer().

Here is the call graph for this function:

◆ pushInstructionReferenceToStack()

void TTAProgram::CodeGenerator::pushInstructionReferenceToStack	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	stackRegister,
		TTAProgram::InstructionReference &	srcAddr
	)

Definition at line 503 of file CodeGenerator.cc.

                                             {
    // create terminal references
    TTAProgram::TerminalInstructionReference* srcTerminal =
        new TTAProgram::TerminalInstructionReference(srcAddr);
 
    pushToStack(dstProcedure, stackRegister, srcTerminal);
}

References pushToStack().

Referenced by createSchedYieldProcedure(), and llvm::LLVMTCEBuilder::emitSetjmp().

Here is the call graph for this function:

◆ pushRegisterToBuffer()

void TTAProgram::CodeGenerator::pushRegisterToBuffer	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	indexRegister,
		const TCEString &	srcReg
	)

Push a value in a register to a buffer.

Parameters

dstProcedure	Procedure to add the moves to.
indexRegister	Pointer to the buffer.
srcTerminal	Value to push.

Definition at line 585 of file CodeGenerator.cc.

                             {
 
    storeToRegisterAddress(dstProcedure, indexRegister, srcReg);
 
    incrementRegisterAddress(dstProcedure, indexRegister, 4);
}

References incrementRegisterAddress(), and storeToRegisterAddress().

Here is the call graph for this function:

◆ pushRegisterToStack()

void TTAProgram::CodeGenerator::pushRegisterToStack	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	stackRegister,
		const TCEString &	srcReg
	)

Push a value in a register to the stack.

Parameters

dstProcedure	Procedure to add the moves to.
stackRegister	Stack pointer name.
srcTerminal	Value to push.

Definition at line 493 of file CodeGenerator.cc.

                             {
    decrementStackPointer(dstProcedure, stackRegister);
 
    storeToRegisterAddress(dstProcedure, stackRegister, srcReg);
}

References decrementStackPointer(), and storeToRegisterAddress().

Referenced by createSchedYieldProcedure(), and llvm::LLVMTCEBuilder::emitSetjmp().

Here is the call graph for this function:

◆ pushToBuffer()

void TTAProgram::CodeGenerator::pushToBuffer	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	indexRegister,
		TTAProgram::Terminal *	srcTerminal
	)

Push a value in a terminal to a buffer.

Parameters

dstProcedure	Procedure to add the moves to.
indexRegister	Pointer to the buffer.
srcTerminal	Value to push.

Definition at line 565 of file CodeGenerator.cc.

                                     {
 
    TTAProgram::Terminal* indexTerminal =
        createTerminalRegister(indexRegister, true);
    storeTerminal(dstProcedure, indexTerminal, srcTerminal);
 
    incrementRegisterAddress(dstProcedure, indexRegister, 4);
}

References createTerminalRegister(), incrementRegisterAddress(), and storeTerminal().

Referenced by pushInstructionReferenceToBuffer().

Here is the call graph for this function:

◆ pushToStack()

void TTAProgram::CodeGenerator::pushToStack	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	stackRegister,
		TTAProgram::Terminal *	srcTerminal
	)

Push a value in a terminal to the stack.

Parameters

dstProcedure	Procedure to add the moves to.
stackRegister	Stack pointer name.
srcTerminal	Value to push.

Definition at line 474 of file CodeGenerator.cc.

                                     {
    decrementStackPointer(dstProcedure, stackRegister);
 
    TTAProgram::Terminal* stackTerminal =
        createTerminalRegister(stackRegister, true);
    storeTerminal(dstProcedure, stackTerminal, srcTerminal);
}

References createTerminalRegister(), decrementStackPointer(), and storeTerminal().

Referenced by llvm::LLVMTCEBuilder::emitLongjmp(), llvm::LLVMTCEBuilder::emitSetjmp(), and pushInstructionReferenceToStack().

Here is the call graph for this function:

◆ registerJump() [1/2]

void TTAProgram::CodeGenerator::registerJump	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	jumpAddrReg
	)

Definition at line 609 of file CodeGenerator.cc.

                                  {
 
    TTAProgram::Terminal* jumpDestTerminal =
        createTerminalRegister(jumpAddrReg, true);
 
    TTAProgram::TerminalFUPort* jump1Terminal =
        createTerminalFUPort("jump", 1);
 
    // dstProcedure->add(new CodeSnippet("jumpAddrReg -> jmp.1;"));
    addMoveToProcedure(dstProcedure, jumpDestTerminal, jump1Terminal);
}

References addMoveToProcedure(), createTerminalFUPort(), and createTerminalRegister().

Referenced by createSchedYieldProcedure(), llvm::LLVMTCEBuilder::emitLongjmp(), and llvm::LLVMTCEBuilder::emitReturnTo().

Here is the call graph for this function:

◆ registerJump() [2/2]

void TTAProgram::CodeGenerator::registerJump	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	jumpAddrReg,
		const TTAProgram::ProgramAnnotation &	annotation
	)

Definition at line 624 of file CodeGenerator.cc.

                                                   {
 
    TTAProgram::Terminal* jumpDestTerminal =
        createTerminalRegister(jumpAddrReg, true);
 
    TTAProgram::TerminalFUPort* jump1Terminal =
        createTerminalFUPort("jump", 1);
 
    addAnnotatedMoveToProcedure(
        dstProcedure, jumpDestTerminal, jump1Terminal, annotation);
}

References addAnnotatedMoveToProcedure(), createTerminalFUPort(), and createTerminalRegister().

Here is the call graph for this function:

◆ registerMove()

void TTAProgram::CodeGenerator::registerMove	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	srcReg,
		const TCEString &	dstReg
	)

Definition at line 703 of file CodeGenerator.cc.

                                                      {
 
    TTAProgram::Terminal* srcTerminal =
        createTerminalRegister(srcReg, true);
 
    TTAProgram::Terminal* dstTerminal =
        createTerminalRegister(dstReg, false);
 
    addMoveToProcedure(dstProcedure, srcTerminal, dstTerminal);
}

References addMoveToProcedure(), and createTerminalRegister().

Referenced by createSchedYieldProcedure().

Here is the call graph for this function:

◆ storeTerminal()

void TTAProgram::CodeGenerator::storeTerminal	(	TTAProgram::CodeSnippet &	dstProcedure,
		TTAProgram::Terminal *	dstTerminal,
		TTAProgram::Terminal *	srcTerminal
	)

Store terminal to address in a terminal.

Parameters

dstProcedure	Procedure to add the moves to.
dstTerminal	Address to store to.
srcTerminal	Terminal to store.

Definition at line 213 of file CodeGenerator.cc.

                                     {
    TCEString storeOp;
    int width = 0;
    if (srcTerminal->isGPR()) {
        width = srcTerminal->registerFile().width();
    }
    int defaultWidth = mach_->is64bit() ? 64 : 32;
    if (width < defaultWidth) {
        width = defaultWidth;
    }
 
    if (mach_->isLittleEndian()) {
        storeOp = (boost::format("st%d") % width).str();
    } else {
        storeOp = "stw";
    }
    if (opset_.count(storeOp) == 0) {
        abortWithError(
            (boost::format("Operation %s not found in the machine") % storeOp)
                .str());
    }
 
    TTAProgram::TerminalFUPort* stw1Terminal =
        createTerminalFUPort(storeOp, 1);
 
    TTAProgram::TerminalFUPort* stw2Terminal =
        createTerminalFUPort(storeOp, 2);
 
    addMoveToProcedure(dstProcedure, dstTerminal, stw1Terminal);
    addMoveToProcedure(dstProcedure, srcTerminal, stw2Terminal);
}

References abortWithError, addMoveToProcedure(), createTerminalFUPort(), TTAMachine::Machine::is64bit(), TTAProgram::Terminal::isGPR(), TTAMachine::Machine::isLittleEndian(), mach_, opset_, TTAProgram::Terminal::registerFile(), and TTAMachine::BaseRegisterFile::width().

Referenced by pushToBuffer(), pushToStack(), and storeToAddress().

Here is the call graph for this function:

◆ storeToAddress()

void TTAProgram::CodeGenerator::storeToAddress	(	TTAProgram::CodeSnippet &	dstProcedure,
		TTAProgram::Terminal *	dstTerminal,
		const TCEString &	srcReg
	)

Store register to address in a terminal.

Parameters

dstProcedure	Procedure to add the moves to.
dstTerminal	Address to store to.
srcReg	Register to store.

Definition at line 276 of file CodeGenerator.cc.

                             {
 
    TTAProgram::Terminal* srcRegTerminal =
        createTerminalRegister(srcReg, true);
 
    storeTerminal(dstProcedure, dstTerminal, srcRegTerminal);
}

References createTerminalRegister(), and storeTerminal().

Referenced by llvm::LLVMTCEBuilder::emitSetjmp(), and storeToRegisterAddress().

Here is the call graph for this function:

◆ storeToRegisterAddress()

void TTAProgram::CodeGenerator::storeToRegisterAddress	(	TTAProgram::CodeSnippet &	dstProcedure,
		const TCEString &	dstReg,
		const TCEString &	srcReg
	)

Store register to address in another register.

Parameters

dstProcedure	Procedure to add the moves to.
dstReg	Address to store to.
srcReg	Register to store.

Definition at line 315 of file CodeGenerator.cc.

                             {
 
    // create terminal references
    TTAProgram::Terminal* dstTerminal =
        createTerminalRegister(dstReg, true);
 
    storeToAddress(dstProcedure, dstTerminal, srcReg);
}

References createTerminalRegister(), and storeToAddress().

Referenced by pushRegisterToBuffer(), and pushRegisterToStack().

Here is the call graph for this function:

Member Data Documentation

◆ mach_

const TTAMachine::Machine* TTAProgram::CodeGenerator::mach_

private

Target machine.

Definition at line 220 of file CodeGenerator.hh.

Referenced by createBreakOperation(), createForLoopBufferInit(), createSchedYieldProcedure(), createTerminalRegister(), createWhileLoopBufferInit(), decrementRegisterAddress(), incrementRegisterAddress(), loadTerminal(), and storeTerminal().

◆ opset_

MachineInfo::OperationSet TTAProgram::CodeGenerator::opset_

private

Definition at line 225 of file CodeGenerator.hh.

Referenced by CodeGenerator(), loadTerminal(), and storeTerminal().

◆ stackAlignment_

int TTAProgram::CodeGenerator::stackAlignment_

private

Definition at line 224 of file CodeGenerator.hh.

Referenced by CodeGenerator(), decrementStackPointer(), and incrementStackPointer().

◆ uMach_

const UniversalMachine* TTAProgram::CodeGenerator::uMach_

private

Universal machine.

Definition at line 222 of file CodeGenerator.hh.

Referenced by addAnnotatedMoveToProcedure(), addMoveToProcedure(), createBreakOperation(), createCall(), createForLoopBufferInit(), createJump(), createMove(), createTerminalFUPort(), createTerminalRegister(), and createWhileLoopBufferInit().

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

Public Types

Public Member Functions

Static Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ RegisterSet

Constructor & Destructor Documentation

◆ CodeGenerator()

◆ ~CodeGenerator()

Member Function Documentation

◆ addAnnotatedMoveToProcedure()

◆ addMoveToProcedure()

◆ createBreakOperation()

◆ createCall() [1/2]

◆ createCall() [2/2]

◆ createExternalCall()

◆ createForLoopBufferInit()

◆ createInverseGuard()

◆ createJump()

◆ createMove()

◆ createSchedYieldProcedure()

◆ createTerminalFUPort()

◆ createTerminalRegister() [1/2]

◆ createTerminalRegister() [2/2]

◆ createWhileLoopBufferInit()

◆ decrementRegisterAddress()

◆ decrementStackPointer()

◆ immediateMove()

◆ incrementRegisterAddress()

◆ incrementStackPointer()

◆ loadFromAddress()

◆ loadFromRegisterAddress()

◆ loadTerminal()

◆ popFromBuffer()

◆ popFromStack()

◆ popRegisterFromBuffer()

◆ popRegisterFromStack()

◆ pushInstructionReferenceToBuffer()

◆ pushInstructionReferenceToStack()

◆ pushRegisterToBuffer()

◆ pushRegisterToStack()

◆ pushToBuffer()

◆ pushToStack()

◆ registerJump() [1/2]

◆ registerJump() [2/2]

◆ registerMove()

◆ storeTerminal()

◆ storeToAddress()

◆ storeToRegisterAddress()

Member Data Documentation

◆ mach_

◆ opset_

◆ stackAlignment_

◆ uMach_