CodeSectionCreator Class Reference

#include <CodeSectionCreator.hh>

Collaboration diagram for CodeSectionCreator:

Classes
struct	InternalElement
struct	InternalSection

Public Member Functions
	CodeSectionCreator (MachineResourceManager &resourceManager, const TTAMachine::Machine &targetMachine, AssemblyParserDiagnostic *parent)
void	newSection (UValue startAddress)
void	addMove (const ParserMove &move)
void	finalize (TPEF::Binary &tpef, LabelManager &labels)
void	cleanup ()

Private Types
enum	ElementType { EMPTY , MOVE , IMMEDIATE }

Private Member Functions
void	startNewInstruction ()
UValue	slotNumber ()
UValue	immediateIndex ()
bool	isDestinationAlreadyWritten (const InternalElement &elem) const
void	addAnnotationes (TPEF::InstructionElement &instrElem, InternalElement &elem, LabelManager &lables) const

Private Attributes
const TTAMachine::Machine &	mach_
InternalSection	internalSection_
	Internal representation of code section.
MachineResourceManager &	resources_
	TPEF Resources and strings.
AssemblyParserDiagnostic *	parent_
	Place to add warnings during compilation.
bool	isNextBegin_
	Next element is starting element of instruction.
UValue	slotNumber_
	Slot number of current move.
UValue	immediateIndex_
	Immediate index.

Static Private Attributes
static const UValue	CODE_RELOC_SIZE = 32
	Bitwidth of immediate value containing address to relocate.

Detailed Description

Read moves and creates TPEF code section out of them.

Definition at line 58 of file CodeSectionCreator.hh.

Member Enumeration Documentation

ElementType

enum CodeSectionCreator::ElementType

private

Type of move element.

Enumerator
EMPTY	Empty move.
MOVE	Data transport.
IMMEDIATE	Long immediate assignment.

Definition at line 80 of file CodeSectionCreator.hh.

                     {
        EMPTY,    ///< Empty move.
        MOVE,     ///< Data transport.
        IMMEDIATE ///< Long immediate assignment.
    };

Constructor & Destructor Documentation

CodeSectionCreator()

CodeSectionCreator::CodeSectionCreator	(	MachineResourceManager &	resourceManager,
		const TTAMachine::Machine &	targetMachine,
		AssemblyParserDiagnostic *	parent
	)

Constructor.

Parameters

resourceManager	TPEF resources and strings.
parent	Assembler root class.

Definition at line 65 of file CodeSectionCreator.cc.

                                      :
    mach_(targetMachine),
    resources_(resourceManager), parent_(parent),
    isNextBegin_(true), slotNumber_(0), immediateIndex_(0) {
}

Member Function Documentation

addAnnotationes()

void CodeSectionCreator::addAnnotationes ( TPEF::InstructionElement &  instrElem, InternalElement &  elem, LabelManager &  labels  ) const

private

Adds annotations of element of internal presentation to TPEF element.

Parameters

instrElem	TPEF InstructionElement where to add annotation data.
elem	Element of internal presentation that caontains annotationes from assembly code.

Exceptions

CompileError

If defined value needs more room that is defined in init data.

Definition at line 636 of file CodeSectionCreator.cc.

                                                                                      {
 
    for (unsigned int i = 0; i < elem.annotationes.size();i++) {
        Word id = elem.annotationes[i].id;
        std::vector<Byte> payload;
        
        for (unsigned int j = 0; j < elem.annotationes[i].payload.size(); j++) {
            InitDataField& initData = elem.annotationes[i].payload[j];
            std::deque<Byte> temp;
            
            UValue value = 0;
            if (initData.litOrExpr.isExpression) {
                value = labels.resolveExpressionValue(elem.asmLineNumber, 
                                                      initData.litOrExpr);
            } else {
                value = initData.litOrExpr.value;
            }
            
            // write value to field
            for (int k = sizeof(value) - 1; k >= 0; k--) {
                Byte nextVal = (value >> (k*BYTE_BITWIDTH));
                temp.push_back(nextVal);               
            }
            
            // remove extra leading ones if signed
            if (initData.litOrExpr.isSigned) {
                while (temp.size() > 1 && temp[0] == 0xff && 
                       temp.size() > initData.width &&
                       (temp[1] & 0x80) != 0) {
 
                    temp.pop_front();
                }                
            }
 
            // remove extra leading zeroes
            while (temp[0] == 0 && temp.size() > initData.width) {
                temp.pop_front();
            }
            
            // add needed leading zeroes or ones if signed            
            while (temp.size() < initData.width) {
 
                if (initData.litOrExpr.isSigned && (temp[0] & 0x80) != 0) {
                    temp.push_front(0xff);
                } else {
                    temp.push_front(0);
                }
 
            }
                                    
            if (initData.width != 0 && temp.size() > initData.width) {
                std::string errorMessage = 
                    "Annotation payload " + initData.toString() + 
                    " is too big for defined field size.";
 
                throw CompileError(
                    __FILE__, __LINE__, __func__,
                    errorMessage);
            }
            
            // add to payload
            for (unsigned int j = 0; j < temp.size(); j++) {
                payload.push_back(temp[j]);
            }
        }
                      
        instrElem.addAnnotation(new InstructionAnnotation(id, payload));
    }
}

References __func__, TPEF::InstructionElement::addAnnotation(), CodeSectionCreator::InternalElement::annotationes, CodeSectionCreator::InternalElement::asmLineNumber, BYTE_BITWIDTH, LiteralOrExpression::isExpression, LiteralOrExpression::isSigned, InitDataField::litOrExpr, LabelManager::resolveExpressionValue(), InitDataField::toString(), LiteralOrExpression::value, and InitDataField::width.

Referenced by finalize().

Here is the call graph for this function:

addMove()

void CodeSectionCreator::addMove

(

const ParserMove &

move

)

Adds new move to section.

If exception is thrown, creator will remain as it was before function call.

Parameters

move	Parsed move.

Exceptions

CompileError

If referenced resource is not found from machine.

Definition at line 102 of file CodeSectionCreator.cc.

                                                  {
    try {
        if (move.isBegin) {
            startNewInstruction();
        }
 
        InternalElement* newMove = NULL;
        InternalElement* newImmediate = NULL;
 
        UValue srcWidth = 0, dstWidth = 0;
 
        switch (move.type) {
 
        case ParserMove::LONG_IMMEDIATE: {
 
            // check that source is valid
            if (move.source.isRegister) {
                CompileError error(
                    __FILE__, __LINE__, __func__,
                    "Internal error: Immediate source must be literal or "
                    "expression.");
 
                error.setCodeFileLineNumber(move.asmLineNumber);
                throw error;
            }
 
            static InternalElement newElement;
            newImmediate = &newElement;
 
            newElement.type = IMMEDIATE;
            newElement.asmLineNumber = move.asmLineNumber;
            newElement.isBegin =  false;
 
            newElement.annotationes = move.annotationes;
 
            // check value bitwidth
            newElement.immValue = move.source.immTerm;
 
            UValue tempValue = newElement.immValue.value;
            while(tempValue > 0) {
                tempValue = tempValue >> 1;
                srcWidth++;
            }
 
            // destination of the immediate
            MachineResourceManager::ResourceID& resID =
                resources_.resourceID(
                    move.asmLineNumber, move.destination, newElement.slot,
                    MachineResourceManager::RQST_WRITE);
 
            newElement.dstType  = resID.type;
 
            if (newElement.dstType != MoveElement::MF_IMM) {
                CompileError error(
                    __FILE__, __LINE__, __func__,
                    "Long immediate destination must be immediate unit.");
 
                error.setCodeFileLineNumber(move.asmLineNumber);
                throw error;
            }
 
            newElement.dstUnit  = resID.unit;
            newElement.dstIndex = resID.index;
            dstWidth = resID.width;
 
        } break;
 
        case ParserMove::EMPTY: {
            static InternalElement newElement;
            newMove = &newElement;
 
            newElement.asmLineNumber = move.asmLineNumber;
            newElement.type = EMPTY;
            newElement.isBegin = move.isBegin;
            newElement.slot = slotNumber();
        } break;
 
        case ParserMove::TRANSPORT: {
            static InternalElement newElement;
            newElement.asmLineNumber = move.asmLineNumber;
            newMove = &newElement;
 
            newElement.slot = slotNumber();
            newElement.type = MOVE;
            
            newElement.annotationes = move.annotationes;
 
            // source
            if (move.source.isRegister) {
 
                MachineResourceManager::ResourceID &resID =
                    resources_.resourceID(
                        move.asmLineNumber,
                        move.source.regTerm, newElement.slot,
                        MachineResourceManager::RQST_READ);
 
                newElement.srcType  = resID.type;
                newElement.srcUnit  = resID.unit;
                newElement.srcIndex = resID.index;
 
                srcWidth = resID.width;
 
            } else {
                // inline immediate
                static InternalElement immediate;
                immediate.asmLineNumber = move.asmLineNumber;
                newImmediate = &immediate;
 
                immediate.slot = newElement.slot;
                immediate.type = IMMEDIATE;
                immediate.dstUnit = ResourceElement::INLINE_IMM;
                immediate.dstIndex = immediateIndex();
                immediate.isBegin =  false;
                immediate.immValue = move.source.immTerm;
 
                newElement.srcType = MoveElement::MF_IMM;
                newElement.srcUnit = immediate.dstUnit;
                newElement.srcIndex = immediate.dstIndex;
 
                // check value bitwidth
                UValue tempValue = immediate.immValue.value;
                while(tempValue > 0) {
                    tempValue = tempValue >> 1;
                    srcWidth++;
                }
            }
 
            // destination
            MachineResourceManager::ResourceID &resID =
                resources_.resourceID(move.asmLineNumber,
                                      move.destination, newElement.slot,
                                      MachineResourceManager::RQST_WRITE);
 
            newElement.dstType  = resID.type;
            newElement.dstUnit  = resID.unit;
            newElement.dstIndex = resID.index;
            newElement.isBegin = move.isBegin;
            dstWidth = resID.width;
 
            // guard
            newElement.isGuarded = move.guard.isGuarded;
 
            if (newElement.isGuarded) {
                newElement.isInverted = move.guard.isInverted;
 
                MachineResourceManager::ResourceID *resID = NULL;
 
                if (newElement.isInverted) {
                    resID = &resources_.resourceID(
                        move.asmLineNumber,
                        move.guard.regTerm, newElement.slot,
                        MachineResourceManager::RQST_INVGUARD);
 
                } else {
                    resID = &resources_.resourceID(
                        move.asmLineNumber,
                        move.guard.regTerm, newElement.slot,
                        MachineResourceManager::RQST_GUARD);
                }
 
                newElement.guardType  = resID->type;
                newElement.guardUnit  = resID->unit;
                newElement.guardIndex = resID->index;
            }
 
            if (isDestinationAlreadyWritten(newElement)) {
                parent_->addWarning(
                    move.asmLineNumber,
                    "Move destination: " +
                    move.destination.toString() +
                    " is already written "
                    "in current instruction.");
            }
 
        } break;
 
        default:
            assert(false);
        }
 
        if (newMove != NULL) {
            // check that there are enough busses with sufficient width for
            // all parsed moves
            try {
                // if source is wider than bus
                UValue busWidth = resources_.findBusWidth(newMove->slot);
                if ( busWidth < srcWidth) {
 
                    parent_->addWarning(
                        move.asmLineNumber,
                        "Bus width: " + 
                        Conversion::toString(busWidth) + 
                        " is smaller than source: " + 
                        Conversion::toString(srcWidth));
                }
                
                // if source or destination is wider than bus
                if (dstWidth < srcWidth) {
                    parent_->addWarning(
                        move.asmLineNumber,
                        "Source is wider than destination.");
                }
 
            } catch (OutOfRange& e) {
                CompileError error(
                    __FILE__, __LINE__, __func__,
                    "Too many bus slots used.");
                error.setCodeFileLineNumber(move.asmLineNumber);
                error.setCause(e);
 
                throw error;
            }
            
            internalSection_.elements.push_back(*newMove);
        }
 
        if (newImmediate != NULL) {
            internalSection_.elements.push_back(*newImmediate);
        }
 
    } catch (IllegalMachine& e) {
        CompileError error(
            __FILE__, __LINE__, __func__, e.errorMessage());
 
        error.setCodeFileLineNumber(move.asmLineNumber);
        error.setCause(e);
 
        throw error;
    }
}

References __func__, AssemblyParserDiagnostic::addWarning(), CodeSectionCreator::InternalElement::annotationes, ParserMove::annotationes, CodeSectionCreator::InternalElement::asmLineNumber, ParserMove::asmLineNumber, assert, ParserMove::destination, CodeSectionCreator::InternalElement::dstIndex, CodeSectionCreator::InternalElement::dstType, CodeSectionCreator::InternalElement::dstUnit, CodeSectionCreator::InternalSection::elements, EMPTY, ParserMove::EMPTY, Exception::errorMessage(), MachineResourceManager::findBusWidth(), ParserMove::guard, CodeSectionCreator::InternalElement::guardIndex, CodeSectionCreator::InternalElement::guardType, CodeSectionCreator::InternalElement::guardUnit, IMMEDIATE, immediateIndex(), ParserSource::immTerm, CodeSectionCreator::InternalElement::immValue, MachineResourceManager::ResourceID::index, TPEF::ResourceElement::INLINE_IMM, internalSection_, CodeSectionCreator::InternalElement::isBegin, ParserMove::isBegin, isDestinationAlreadyWritten(), CodeSectionCreator::InternalElement::isGuarded, ParserGuard::isGuarded, CodeSectionCreator::InternalElement::isInverted, ParserGuard::isInverted, ParserSource::isRegister, ParserMove::LONG_IMMEDIATE, TPEF::MoveElement::MF_IMM, MOVE, parent_, ParserSource::regTerm, ParserGuard::regTerm, MachineResourceManager::resourceID(), resources_, MachineResourceManager::RQST_GUARD, MachineResourceManager::RQST_INVGUARD, MachineResourceManager::RQST_READ, MachineResourceManager::RQST_WRITE, Exception::setCause(), CompileError::setCodeFileLineNumber(), CodeSectionCreator::InternalElement::slot, slotNumber(), ParserMove::source, CodeSectionCreator::InternalElement::srcIndex, CodeSectionCreator::InternalElement::srcType, CodeSectionCreator::InternalElement::srcUnit, startNewInstruction(), RegisterTerm::toString(), Conversion::toString(), ParserMove::TRANSPORT, CodeSectionCreator::InternalElement::type, MachineResourceManager::ResourceID::type, ParserMove::type, MachineResourceManager::ResourceID::unit, LiteralOrExpression::value, and MachineResourceManager::ResourceID::width.

Referenced by AddMoveActor::operator()().

Here is the call graph for this function:

cleanup()

void CodeSectionCreator::cleanup

(

)

Frees all internally allocated data.

Definition at line 518 of file CodeSectionCreator.cc.

                            {
    immediateIndex_ = 0;
    isNextBegin_ = true;
    slotNumber_ = 0;
}

References immediateIndex_, isNextBegin_, and slotNumber_.

Referenced by AssemblerParser::cleanup(), and finalize().

finalize()

void CodeSectionCreator::finalize	(	TPEF::Binary &	tpef,
		LabelManager &	labels
	)

Writes created sections to given binary.

All data stored inside creator is freed after this call, unless exception is thrown.

In case of exception creator restores its state to be same that state was before running finalize() (finalize() can be runned again).

Parameters

tpef	Binary where to created sections should be added.
labels	LabelManager where to add data labels and relocations.

Exceptions

CompileError

If there is any errors during compiling.

Definition at line 347 of file CodeSectionCreator.cc.

                                                               {
    // we don't have to have emty CodeSection
    if (internalSection_.elements.size() > 0) {
 
        CodeSection* codeSection = dynamic_cast<CodeSection*>(
            Section::createSection(Section::ST_CODE));
 
        assert(codeSection != NULL);
 
        try {
            codeSection->setLink(resources_.resourceSection());
            codeSection->setName(resources_.stringToChunk(""));
 
            try {
                codeSection->setASpace(resources_.codeAddressSpace());
 
            } catch (IllegalMachine& e) {
                CompileError error(
                    __FILE__, __LINE__, __func__,
                    "Can't find code address space.");
 
                error.setCause(e);
 
                throw error;
            }
 
            std::vector<ImmediateElement*> recentImmediates;
 
            // create the moves
            for (unsigned int i = 0;
                 i < internalSection_.elements.size(); i++) {
 
                InternalElement &elem = internalSection_.elements[i];
 
                assert(elem.slot <= 0xff);
 
                if (elem.isBegin) {
                    // TODO: Check that the recent long immediates are well
                    // formed, as per following conditions.
 
                    // A valid instruction template exists that encodes
                    // them.
 
                    // The same unit is never written twice.
 
                    // There exists a combination of all destination units
                    // needed.
 
                    // The fields that encode each immediate are wide enough
                    // to encode the given constant.
 
                    recentImmediates.clear();
                }
 
                switch(elem.type) {
                case EMPTY: {
                    MoveElement *emptyMove = new MoveElement();
                    emptyMove->setBegin(elem.isBegin);
                    emptyMove->setEmpty(true);
                    emptyMove->setBus(elem.slot + 1);                    
                    addAnnotationes(*emptyMove, elem, labels);
                    codeSection->addElement(emptyMove);
                } break;
 
                case IMMEDIATE: {
                    ImmediateElement *immElem = new ImmediateElement();
                    immElem->setBegin(elem.isBegin);
 
                    UValue immValue = 0;
                    if (elem.immValue.isExpression) {
 
                        immValue = labels.resolveExpressionValue(
                            elem.asmLineNumber, elem.immValue);
 
                        // MARK
                        ASpaceElement& aSpaceElement = 
                            labels.aSpaceElement(
                                elem.immValue.expression.label);
 
                        const std::string aSpaceName = 
                            labels.aSpaceName(elem.immValue.expression.label);
 
                        std::size_t relocSize = CODE_RELOC_SIZE;
 
                        try {
                            // figure out what is the maximum address of
                            // the referred address space and set it as
                            // the relocation width for the immediate
                            const TTAMachine::AddressSpace* addressSpace =
                                mach_.addressSpaceNavigator().item(aSpaceName);
                            assert(addressSpace != NULL);
                            relocSize = MathTools::requiredBits(
                                static_cast<unsigned int>(
                                    addressSpace->end()));
                        } catch (const Exception& e) {
                            Application::logStream() 
                                << "Could not get access to MOM address space."
                                << std::endl;
                        }
 
 
                        labels.addRelocation(
                            *codeSection, *immElem, aSpaceElement, immValue, 
                            relocSize);
 
                    } else {
                        immValue = elem.immValue.value;
                    }
 
                    immElem->setDestinationUnit(elem.dstUnit);
                    immElem->setDestinationIndex(elem.dstIndex);
                    immElem->setWord(immValue);
 
                    if (immElem->destinationUnit() !=
                        ResourceElement::INLINE_IMM) {
 
                        recentImmediates.push_back(immElem);
                    }
 
                    addAnnotationes(*immElem, elem, labels);
                    codeSection->addElement(immElem);
                } break;
 
                case MOVE: {
                    MoveElement *newMove = new MoveElement();
                    newMove->setEmpty(false);
                    newMove->setBegin(elem.isBegin);
 
                    newMove->setBus(elem.slot + 1);
 
                    newMove->setSourceType(elem.srcType);
                    newMove->setSourceUnit(elem.srcUnit);
                    newMove->setSourceIndex(elem.srcIndex);
 
                    newMove->setDestinationType(elem.dstType);
                    newMove->setDestinationUnit(elem.dstUnit);
                    newMove->setDestinationIndex(elem.dstIndex);
 
                    newMove->setGuardType(elem.guardType);
                    newMove->setGuardUnit(elem.guardUnit);
                    newMove->setGuardIndex(elem.guardIndex);
 
                    newMove->setGuarded(elem.isGuarded);
                    newMove->setGuardInverted(elem.isInverted);
 
                    addAnnotationes(*newMove, elem, labels);
                    codeSection->addElement(newMove);
                } break;
 
                default:
                    assert(false);
                }
            }
 
        } catch (CompileError& e) {
            labels.clearLastRelocations();
            delete codeSection;
            throw e;
        }
 
        labels.commitLastRelocations();
        tpef.addSection(codeSection);
    }
 
    cleanup();
}

References __func__, addAnnotationes(), TPEF::CodeSection::addElement(), LabelManager::addRelocation(), TTAMachine::Machine::addressSpaceNavigator(), TPEF::Binary::addSection(), CodeSectionCreator::InternalElement::asmLineNumber, LabelManager::aSpaceElement(), LabelManager::aSpaceName(), assert, cleanup(), LabelManager::clearLastRelocations(), CODE_RELOC_SIZE, MachineResourceManager::codeAddressSpace(), LabelManager::commitLastRelocations(), TPEF::Section::createSection(), TPEF::ImmediateElement::destinationUnit(), CodeSectionCreator::InternalElement::dstIndex, CodeSectionCreator::InternalElement::dstType, CodeSectionCreator::InternalElement::dstUnit, CodeSectionCreator::InternalSection::elements, EMPTY, TTAMachine::AddressSpace::end(), LiteralOrExpression::expression, CodeSectionCreator::InternalElement::guardIndex, CodeSectionCreator::InternalElement::guardType, CodeSectionCreator::InternalElement::guardUnit, IMMEDIATE, CodeSectionCreator::InternalElement::immValue, TPEF::ResourceElement::INLINE_IMM, internalSection_, CodeSectionCreator::InternalElement::isBegin, LiteralOrExpression::isExpression, CodeSectionCreator::InternalElement::isGuarded, CodeSectionCreator::InternalElement::isInverted, TTAMachine::Machine::Navigator< ComponentType >::item(), Expression::label, Application::logStream(), mach_, MOVE, MathTools::requiredBits(), LabelManager::resolveExpressionValue(), resources_, MachineResourceManager::resourceSection(), TPEF::Section::setASpace(), TPEF::InstructionElement::setBegin(), TPEF::MoveElement::setBus(), Exception::setCause(), TPEF::ImmediateElement::setDestinationIndex(), TPEF::MoveElement::setDestinationIndex(), TPEF::MoveElement::setDestinationType(), TPEF::ImmediateElement::setDestinationUnit(), TPEF::MoveElement::setDestinationUnit(), TPEF::MoveElement::setEmpty(), TPEF::MoveElement::setGuarded(), TPEF::MoveElement::setGuardIndex(), TPEF::MoveElement::setGuardInverted(), TPEF::MoveElement::setGuardType(), TPEF::MoveElement::setGuardUnit(), TPEF::Section::setLink(), TPEF::Section::setName(), TPEF::MoveElement::setSourceIndex(), TPEF::MoveElement::setSourceType(), TPEF::MoveElement::setSourceUnit(), TPEF::ImmediateElement::setWord(), CodeSectionCreator::InternalElement::slot, CodeSectionCreator::InternalElement::srcIndex, CodeSectionCreator::InternalElement::srcType, CodeSectionCreator::InternalElement::srcUnit, TPEF::Section::ST_CODE, MachineResourceManager::stringToChunk(), CodeSectionCreator::InternalElement::type, and LiteralOrExpression::value.

Referenced by AssemblerParser::finalize().

Here is the call graph for this function:

immediateIndex()

UValue CodeSectionCreator::immediateIndex ( )

private

Returns next possible index for inline immediate.

Returns

Next possible index for inline immediate.

Definition at line 550 of file CodeSectionCreator.cc.

                                   {
    immediateIndex_++;
    return immediateIndex_;
}

References immediateIndex_.

Referenced by addMove().

isDestinationAlreadyWritten()

bool CodeSectionCreator::isDestinationAlreadyWritten ( const InternalElement &  elem ) const

private

Returns true if RF index or FU port is written twice in a same instruction.

Parameters

elem	Move to check.

Returns

True if RF index or FU port is written twice in a same instruction.

Definition at line 562 of file CodeSectionCreator.cc.

                                       {
 
    if (elem.type == MOVE && !elem.isBegin) {
 
        std::vector<const InternalElement*> guardedMoves;
 
        for (int i = internalSection_.elements.size() - 1;
             i >= 0 && !internalSection_.elements[i].isBegin; i--) {
 
            const InternalElement &compare = internalSection_.elements[i];
 
            if (compare.type == elem.type &&
                compare.dstType == elem.dstType &&
                compare.dstUnit == elem.dstUnit &&
                compare.dstIndex == elem.dstIndex) {
 
                if (!compare.isGuarded || !elem.isGuarded) {
                    // destination is same and only one of the moves 
                    // is  guarded
                    return true;
 
                } else {
 
                    if (compare.guardType == elem.guardType &&
                        compare.guardUnit == elem.guardUnit &&
                        compare.guardIndex == elem.guardIndex &&
                        compare.isInverted == elem.isInverted) {
 
                        // same destination and same guards
                        return true;
                    }
 
                    // gather possibly colliding moves
                    guardedMoves.push_back(&compare);
                }
            }
 
        }
 
        // check if possibly colliding moves has two opposites of same guard
        for (unsigned int i = 0; i < guardedMoves.size(); i++) {
            for (unsigned int j = i + 1; j < guardedMoves.size(); j++) {
 
                const InternalElement* iMove = guardedMoves[i];
                const InternalElement* jMove = guardedMoves[j];
 
                if (iMove->guardType == jMove->guardType &&
                    iMove->guardUnit == jMove->guardUnit &&
                    iMove->guardIndex == jMove->guardIndex &&
                    iMove->isInverted != jMove->isInverted) {
 
                    // destination that is currently written is
                    // definately already written in this instruction
                    return true;
                }
            }
        }
    }
 
    return false;
}

References CodeSectionCreator::InternalElement::dstIndex, CodeSectionCreator::InternalElement::dstType, CodeSectionCreator::InternalElement::dstUnit, CodeSectionCreator::InternalSection::elements, CodeSectionCreator::InternalElement::guardIndex, CodeSectionCreator::InternalElement::guardType, CodeSectionCreator::InternalElement::guardUnit, internalSection_, CodeSectionCreator::InternalElement::isBegin, CodeSectionCreator::InternalElement::isGuarded, CodeSectionCreator::InternalElement::isInverted, MOVE, and CodeSectionCreator::InternalElement::type.

Referenced by addMove().

newSection()

void CodeSectionCreator::newSection

(

UValue

startAddress

)

Creator to start new section from given start address.

Parameters

startAddress

Start address of next section.

Exceptions

OutOfRange

Start address is not in code address space.

Definition at line 81 of file CodeSectionCreator.cc.

                                                  {
    // Checks are not needed yet, since we support currently only
    // one code section.
 
    // @todo if multiple times then create new section each time..
    //       for now only one code section is supported
 
    // @todo  sanity checks for addresses and moves (next is begin...)
 
    internalSection_.startAddress = startAddress;
}

References internalSection_, and CodeSectionCreator::InternalSection::startAddress.

Referenced by NewCodeSectionActor::operator()().

slotNumber()

UValue CodeSectionCreator::slotNumber ( )

private

Returns slot number for currently added move.

Returns

Slot number for currently added move.

Definition at line 539 of file CodeSectionCreator.cc.

                               {
    slotNumber_++;
    return slotNumber_ - 1;
}

References slotNumber_.

Referenced by addMove().

startNewInstruction()

void CodeSectionCreator::startNewInstruction ( )

private

Inits privat attributes for start of new instruction.

Definition at line 528 of file CodeSectionCreator.cc.

                                        {
    slotNumber_ = 0;
    immediateIndex_ = 0;
}

References immediateIndex_, and slotNumber_.

Referenced by addMove().

Member Data Documentation

CODE_RELOC_SIZE

const UValue CodeSectionCreator::CODE_RELOC_SIZE = 32

staticprivate

Bitwidth of immediate value containing address to relocate.

Definition at line 178 of file CodeSectionCreator.hh.

Referenced by finalize().

immediateIndex_

UValue CodeSectionCreator::immediateIndex_

private

Immediate index.

Definition at line 175 of file CodeSectionCreator.hh.

Referenced by cleanup(), immediateIndex(), and startNewInstruction().

internalSection_

InternalSection CodeSectionCreator::internalSection_

private

Internal representation of code section.

Definition at line 160 of file CodeSectionCreator.hh.

Referenced by addMove(), finalize(), isDestinationAlreadyWritten(), and newSection().

isNextBegin_

bool CodeSectionCreator::isNextBegin_

private

Next element is starting element of instruction.

Definition at line 169 of file CodeSectionCreator.hh.

Referenced by cleanup().

mach_

const TTAMachine::Machine& CodeSectionCreator::mach_

private

Definition at line 157 of file CodeSectionCreator.hh.

Referenced by finalize().

parent_

AssemblyParserDiagnostic* CodeSectionCreator::parent_

private

Place to add warnings during compilation.

Definition at line 166 of file CodeSectionCreator.hh.

Referenced by addMove().

resources_

MachineResourceManager& CodeSectionCreator::resources_

private

TPEF Resources and strings.

Definition at line 163 of file CodeSectionCreator.hh.

Referenced by addMove(), and finalize().

slotNumber_

UValue CodeSectionCreator::slotNumber_

private

Slot number of current move.

Definition at line 172 of file CodeSectionCreator.hh.

Referenced by cleanup(), slotNumber(), and startNewInstruction().

---

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

• CodeSectionCreator.hh
• CodeSectionCreator.cc