TTAProgram::ProgramWriter Class Reference

#include <ProgramWriter.hh>

Collaboration diagram for TTAProgram::ProgramWriter:

Classes
struct	RelocInfo
struct	ResourceID

Public Member Functions
	ProgramWriter (const Program &prog)
TPEF::Binary *	createBinary () const

Static Public Member Functions
static TPEF::Binary *	createBinary (const Program &prog)

Private Member Functions
void	createCodeSection (TPEF::CodeSection *code, TPEFResourceUpdater &updater) const
void	createDataSections (TPEF::Binary *bin, bool littleEndian) const
void	createRelocSections (TPEF::Binary *bin) const
TPEF::Section &	findSection (TPEF::Binary &bin, Address address) const
ResourceID	terminalResource (const Terminal &term, TPEFResourceUpdater &updater) const
TPEF::Binary::FileType	resolveFileType (TPEF::ResourceSection &resources) const
TPEF::ASpaceElement &	createASpaceElement (const TTAMachine::AddressSpace &addressSpace, TPEF::Binary &bin) const

Private Attributes
const Program &	prog_
	Program that is written to TPEF.
std::map< const TTAMachine::AddressSpace *, TPEF::ASpaceElement * >	aSpaceMap_
	Created TPEF binary.
std::vector< RelocInfo >	relocInfos_

Static Private Attributes
static const HalfWord	IMMEDIATE_ADDRESS_WIDTH = WORD_BITWIDTH
	Default widt that is used as address width of relocations of immediate elements. This should be fixed by checking width from bus or template.
static const int	MAX_SIMM_WIDTH = 64
	Maximum width for short immediates.

Detailed Description

Writes new TPEF out of POM and original TPEF.

Writer creates creates whole new code section, code relocation section, resource section and symbol section for code symbols. Data sections, uninitialized data sections and data to data relocations are also copied from original TPEF.

Client of POM has to write data to code relocations and all sections that client wants to preserve from original TPEF.

Definition at line 141 of file ProgramWriter.hh.

Constructor & Destructor Documentation

ProgramWriter()

TTAProgram::ProgramWriter::ProgramWriter

(

const Program &

prog

)

Constructor.

Parameters

prog	Program that from TPEF is created.

Definition at line 688 of file ProgramWriter.cc.

                        :
    prog_(prog) {
}

Member Function Documentation

createASpaceElement()

TPEF::ASpaceElement & TTAProgram::ProgramWriter::createASpaceElement ( const TTAMachine::AddressSpace &  addressSpace, TPEF::Binary &  bin  ) const

private

Creates new address space element to binary or returns already created one.

This function should be used always with same TPEF bin.

Parameters

addressSpace	ADF address space whose TPEF version is needed.
bin	Binary to which created address space is added.

Returns

Address space element of corresponding ADF address space.

Definition at line 1544 of file ProgramWriter.cc.

                                                                        {
 
    StringSection* strings = dynamic_cast<StringSection*>(
        bin.section(Section::ST_STRTAB,0));
    Section* aSpaceSection = bin.section(Section::ST_ADDRSP,0);
    
    // create new address space if necessary
    if (!MapTools::containsKey(aSpaceMap_, &addressSpace)) {
        ASpaceElement *newASpace = new ASpaceElement();
 
        // set mau of instruction address space to be 0
        if (&addressSpace ==  
            prog_.targetProcessor().controlUnit()->addressSpace()) {
            newASpace->setMAU(0);
        } else {
            newASpace->setMAU(addressSpace.width());
        }
        newASpace->setName(
            strings->string2Chunk(addressSpace.name()));
        aSpaceSection->addElement(newASpace);
        aSpaceMap_[&addressSpace] = newASpace;
    }
    
    return  *aSpaceMap_[&addressSpace];
}

References TPEF::Section::addElement(), TTAMachine::FunctionUnit::addressSpace(), aSpaceMap_, MapTools::containsKey(), TTAMachine::Machine::controlUnit(), TTAMachine::Component::name(), prog_, TPEF::Binary::section(), TPEF::ASpaceElement::setMAU(), TPEF::ASpaceElement::setName(), TPEF::StringSection::string2Chunk(), TTAProgram::Program::targetProcessor(), and TTAMachine::AddressSpace::width().

Referenced by createBinary(), createDataSections(), createRelocSections(), and findSection().

Here is the call graph for this function:

createBinary() [1/2]

Binary * TTAProgram::ProgramWriter::createBinary

(

)

const

Creates TPEF binary.

Returns

TPEF binary of a program.

Definition at line 700 of file ProgramWriter.cc.

                                  {
    Binary* newBin = new Binary();
        
    // create and initialize sections
    NullSection* nullSection = dynamic_cast<NullSection*>(
        Section::createSection(Section::ST_NULL));
 
    StringSection* strings = dynamic_cast<StringSection*>(
        Section::createSection(Section::ST_STRTAB));
    strings->addByte(0);
 
    ASpaceSection* aSpaces = dynamic_cast<ASpaceSection*>(
        Section::createSection(Section::ST_ADDRSP));
 
    ASpaceElement* undefASpace = new ASpaceElement();
    undefASpace->setName(strings->string2Chunk(""));
    aSpaces->setUndefinedASpace(undefASpace);
 
    // check instruction address space from adf and init instruction space
    Machine& adf = prog_.targetProcessor();
    ControlUnit* unit = adf.controlUnit();
    AddressSpace* adfInstrASpace = unit->addressSpace();
 
    if (prog_.instructionCount() > 0 && 
        (prog_.startAddress().location() < adfInstrASpace->start() ||
        prog_.startAddress().location() + prog_.instructionCount() > 
        adfInstrASpace->end())) {
        TCEString err = 
            "The program is out of bounds of the imem." 
            " Please increase the instruction address space size in adf or "
            " make the program smaller. "
            "Using a smaller unroll and/or inlining threshold may help.";
        err << " Imem address space size: "
            << (adfInstrASpace->end() - adfInstrASpace->start() +1)
            << ", required program size: "
            << prog_.instructionCount();
 
        throw CompileError(__FILE__, __LINE__, __func__, err);
    }
 
    aSpaces->addElement(undefASpace);
 
    ResourceSection* resources = dynamic_cast<ResourceSection*>(
        Section::createSection(Section::ST_MR));
 
    CodeSection* code =
        dynamic_cast<CodeSection*>(Section::createSection(Section::ST_CODE));
 
    SymbolSection* symbols =
        dynamic_cast<SymbolSection*>(
            Section::createSection(Section::ST_SYMTAB));
 
    NoTypeSymElement *undefSymbol = new NoTypeSymElement();
    undefSymbol->setName(strings->string2Chunk(""));
    symbols->addElement(undefSymbol);
 
    // add sections to binary
    newBin->addSection(nullSection);
    newBin->addSection(aSpaces);
    newBin->addSection(strings);
    newBin->addSection(resources);
    newBin->addSection(code);
    newBin->addSection(symbols);
    newBin->setStrings(strings);
 
    // set link fields
    nullSection->setLink(nullSection);
    strings->setLink(nullSection);
    aSpaces->setLink(strings);
    resources->setLink(strings);
    code->setLink(resources);
    symbols->setLink(strings);
 
    // set name fields
    nullSection->setName(strings->string2Chunk(""));
    strings->setName(strings->string2Chunk(""));
    aSpaces->setName(strings->string2Chunk(""));
    resources->setName(strings->string2Chunk(""));
    code->setName(strings->string2Chunk(""));
    symbols->setName(strings->string2Chunk(""));
 
    // set adress space fields
    nullSection->setASpace(undefASpace);
    strings->setASpace(undefASpace);
    aSpaces->setASpace(undefASpace);
    resources->setASpace(undefASpace);
    code->setASpace(&createASpaceElement(*adfInstrASpace, *newBin));
    symbols->setASpace(undefASpace);
 
    TPEFResourceUpdater resourceUpdater(prog_.targetProcessor(), *resources);
 
    createCodeSection(code, resourceUpdater);
    createDataSections(newBin, adf.isLittleEndian());
 
    // TODO: add labels here (all labels are inserted at once from skope
    // information after writing porgram sections)
 
    // TODO: refactor this...
 
    // procedure symbols
    for (int i = 0; i < prog_.procedureCount(); i++) {
        Procedure &currProced = prog_.procedure(i);
 
        // create CodeSymElement and add it to symbols
        ProcedSymElement *procedSym = new ProcedSymElement();
 
        procedSym->setAbsolute(false);
        procedSym->setBinding(SymbolElement::STB_LOCAL);
 
        procedSym->setName(
            strings->string2Chunk(currProced.name()));
 
        procedSym->setSection(code);
 
        procedSym->setReference(
            &code->instruction(currProced.startAddress().location()));
 
        symbols->addElement(procedSym);
    }
 
    // we add only global scope labels for now
    const GlobalScope &globalScope = prog_.globalScopeConst();
 
    for (int i = 0; i < globalScope.globalCodeLabelCount(); i++) {
        const CodeLabel &currLabel = globalScope.globalCodeLabel(i);
 
        // create CodeSymElement and add it to symbols
        CodeSymElement *codeSym = new CodeSymElement();
 
        codeSym->setAbsolute(false);
        codeSym->setBinding(SymbolElement::STB_GLOBAL);
 
        codeSym->setName(
            strings->string2Chunk(currLabel.name()));
 
        codeSym->setSection(code);
 
        codeSym->setReference(
            &code->instruction(currLabel.address().location()));
 
        symbols->addElement(codeSym);
    }
 
    for (int i = 0; i < globalScope.globalDataLabelCount(); i++) {
        const DataLabel &currLabel = globalScope.globalDataLabel(i);
 
        // create DataSymElement and add it to symbols
        DataSymElement *dataSym = new DataSymElement();
 
        dataSym->setAbsolute(false);
        dataSym->setBinding(SymbolElement::STB_GLOBAL);
 
        dataSym->setName(strings->string2Chunk(currLabel.name()));
 
        // TODO: find section by address. 
        //       refactor to own method (Method is already written)
 
        // it seems that we need to have some kind of data 
        // section finding by address
        ASpaceSection* aSpaces = dynamic_cast<ASpaceSection*>(
            newBin->section(Section::ST_ADDRSP,0));
 
        ASpaceElement* dstASpace = NULL;
 
        // find out dst address space by comparing names
        for (Word k = 0; k < aSpaces->elementCount(); k++) {
            ASpaceElement *currElem = dynamic_cast<ASpaceElement*>(
                aSpaces->element(k));
 
            if (TPEFTools::addressSpaceName(*newBin, *currElem) ==
                currLabel.address().space().name()) {
 
                dstASpace = currElem;
                break;
            }
        }
 
        if (dstASpace == NULL) {
            throw NotAvailable(
                __FILE__, __LINE__, __func__, 
                std::string("Cannot find address space ") + 
                currLabel.address().space().name() + 
                " for data label " + currLabel.name());
                               
        }
        UDataSection* dstSection = NULL;
        LongWord dstAddress = currLabel.address().location();
 
        for (Word k = 0; k < newBin->sectionCount(); k++) {
            UDataSection *currSect = dynamic_cast<UDataSection*>(
                newBin->section(k));
 
            if (currSect != NULL &&
                (currSect->type() == Section::ST_DATA ||
                 currSect->type() == Section::ST_UDATA||
                 currSect->type() == Section::ST_LEDATA) &&
                currSect->aSpace() == dstASpace &&
                currSect->startingAddress() <= dstAddress &&
                dstAddress <
                currSect->startingAddress() + currSect->lengthInMAUs()) {
 
                dstSection = currSect;
                break;
            }
        }
 
        if (dstSection == NULL) {
            abortWithError("Can't find section for data address: " +
                           Conversion::toString(dstAddress));
        }
 
        dataSym->setSection(dstSection);
 
        dstAddress -= dstSection->startingAddress();
 
        dataSym->setReference(
            dstSection->chunk(
                dstSection->MAUsToBytes(dstAddress)));
 
        symbols->addElement(dataSym);
    }
    
    // all the data is written... do the relocations
    createRelocSections(newBin);
 
    // clean up internal tables
    aSpaceMap_.clear();
    relocInfos_.clear();
 
    newBin->setArch(Binary::FA_TTA_TUT);
    newBin->setType(resolveFileType(*resources));
 
    return newBin;
}

References __func__, abortWithError, TPEF::DataSection::addByte(), TPEF::Section::addElement(), TTAProgram::CodeLabel::address(), TTAProgram::Label::address(), TTAMachine::FunctionUnit::addressSpace(), TPEF::Binary::addSection(), TPEF::Section::aSpace(), aSpaceMap_, TPEF::RawSection::chunk(), TTAMachine::Machine::controlUnit(), createASpaceElement(), createCodeSection(), createDataSections(), createRelocSections(), TPEF::Section::element(), TPEF::Section::elementCount(), TTAMachine::AddressSpace::end(), TTAProgram::GlobalScope::globalCodeLabel(), TTAProgram::GlobalScope::globalCodeLabelCount(), TTAProgram::GlobalScope::globalDataLabel(), TTAProgram::GlobalScope::globalDataLabelCount(), TTAProgram::Program::globalScopeConst(), TPEF::CodeSection::instruction(), TTAProgram::Program::instructionCount(), TTAMachine::Machine::isLittleEndian(), TPEF::RawSection::lengthInMAUs(), TTAProgram::Address::location(), TPEF::RawSection::MAUsToBytes(), TTAMachine::Component::name(), TTAProgram::Label::name(), TTAProgram::Procedure::name(), TTAProgram::Program::procedure(), TTAProgram::Program::procedureCount(), prog_, relocInfos_, resolveFileType(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), TPEF::SymbolElement::setAbsolute(), TPEF::Binary::setArch(), TPEF::Section::setASpace(), TPEF::SymbolElement::setBinding(), TPEF::Section::setLink(), TPEF::SymbolElement::setName(), TPEF::ASpaceElement::setName(), TPEF::Section::setName(), TPEF::DataSymElement::setReference(), TPEF::CodeSymElement::setReference(), TPEF::SymbolElement::setSection(), TPEF::Binary::setStrings(), TPEF::Binary::setType(), TPEF::ASpaceSection::setUndefinedASpace(), TTAProgram::Address::space(), TTAMachine::AddressSpace::start(), TTAProgram::CodeSnippet::startAddress(), TTAProgram::Program::startAddress(), TPEF::Section::startingAddress(), TPEF::StringSection::string2Chunk(), TTAProgram::Program::targetProcessor(), Conversion::toString(), and TPEF::UDataSection::type().

Referenced by createBinary(), RemoteController::loadIMemImage(), ProgrammabilityValidator::profile(), and TTAProgram::Program::writeToTPEF().

createBinary() [2/2]

TPEF::Binary * TTAProgram::ProgramWriter::createBinary ( const Program &  prog )

static

Creates TPEF binary of given Program.

Returns

TPEF binary of a program.

Definition at line 941 of file ProgramWriter.cc.

                                               {
    ProgramWriter writer(prog);
    return writer.createBinary();
}

References createBinary().

Here is the call graph for this function:

createCodeSection()

void TTAProgram::ProgramWriter::createCodeSection ( TPEF::CodeSection *  code, TPEFResourceUpdater &  updater  ) const

private

Creates code section.

Parameters

code	Code section where to instructions are added.
updater	Resource updater for finding TPEF resources for machine parts.

Definition at line 954 of file ProgramWriter.cc.

                                        {
 
    // add all busses from machine to resource section
    Machine& adf = prog_.targetProcessor();
    Machine::BusNavigator navi = adf.busNavigator();
    for (int i = 0; i < navi.count(); i++) {
        // just call once for each bus, to make sure that all busses
        // are written to machine resource table.
        updater.bus(*navi.item(i));
    }
 
    code->setStartingAddress(prog_.startAddress().location());
 
    for (int i = 0; i < prog_.procedureCount(); i++) {
        Procedure& currProcedure = prog_.procedure(i);
 
        for (int j = 0; j < currProcedure.instructionCount(); j++) {
            Instruction &currInstr = currProcedure.instructionAtIndex(j);
            HalfWord immediateIndex = 0;
            bool beginFlag = true;
 
            for (int k = 0; k < currInstr.moveCount(); k++) {
                Move& progMove = currInstr.move(k);
                MoveElement* tpefMove = new MoveElement();
 
                tpefMove->setBegin(beginFlag);
                beginFlag = false;
                tpefMove->setBus(updater.bus(progMove.bus()).id());
                tpefMove->setEmpty(false);
 
                // add the possible move annotations
                if (progMove.hasAnnotations()) {
                    for (int annotationIndex = 0; 
                         annotationIndex < progMove.annotationCount(); 
                         ++annotationIndex) {
                        const ProgramAnnotation& annot =
                            progMove.annotation(annotationIndex);
                        tpefMove->addAnnotation(
                            new InstructionAnnotation(
                                annot.id(), annot.payload()));
                    }
                }
 
                code->addElement(tpefMove);
 
                if (!tpefMove->isEmpty()) {
 
                    // set source
                    if (!progMove.source().isImmediate()) {
 
                        ResourceID sourceId =
                            terminalResource(progMove.source(), updater);
 
#if 0
                        std::cerr << "src type: " << sourceId.type
                                  << "\tunit: " << sourceId.unit
                                  << "\tindex: " << sourceId.index
                                  << std::endl;
#endif
 
                        tpefMove->setSourceType(sourceId.type);
                        tpefMove->setSourceUnit(sourceId.unit);
                        tpefMove->setSourceIndex(sourceId.index);
 
                    } else {
 
                        ImmediateElement *newImmediate = 
                            new ImmediateElement();
                        newImmediate->setBegin(false);
 
                        const TTAProgram::TerminalImmediate& termImm =
                            dynamic_cast<TerminalImmediate&>(
                                progMove.source());
 
                        // add the possible immediate annotations
                        if (termImm.hasAnnotations()) {
                            for (int annotationIndex = 0; 
                                 annotationIndex < termImm.annotationCount(); 
                                 ++annotationIndex) {
                                const ProgramAnnotation& annot =
                                    termImm.annotation(annotationIndex);
                                newImmediate->addAnnotation(
                                    new InstructionAnnotation(
                                        annot.id(), annot.payload()));
                            }
                        }
 
 
                        // check that inline immediate fits to bus's 
                        // inline immediate field
                        unsigned long wordToStore =
                            progMove.source().value().uLongWordValue();
 
                        unsigned long uvalue = wordToStore;
                        int requiredBits = 0;
                        int fieldWidth = progMove.bus().immediateWidth();
 
                        // TODO: why here? immediateelement can handle this???
                        if (progMove.bus().signExtends()) {
                            // Interpret as signed and sign extend if needed
                            long svalue = static_cast<long>(uvalue);
                            if (fieldWidth < MAX_SIMM_WIDTH) {
                                svalue = MathTools::signExtendTo(
                                    svalue, fieldWidth);
                            }
                            requiredBits = 
                                MathTools::requiredBitsSigned(svalue);
                        } else {
                            requiredBits = 
                                MathTools::requiredBits(uvalue);
                        }
                      
                        if (requiredBits <= fieldWidth) {
                            wordToStore = 
                                MathTools::zeroExtendTo(
                                    wordToStore, fieldWidth);
                        } else {
                            TCEString disasm = POMDisassembler::disassemble(progMove);
                            long location =
                                progMove.parent().address().location();
                            TCEString message = "In procedure:";
                            message << currProcedure.name() <<  " Move: " <<
                                disasm << " Inline immediate value " <<
                                progMove.source().value().unsignedValue() <<
                                " of required width " <<
                                Conversion::toString(requiredBits) <<
                                " at location " <<
                                Conversion::toString(location) <<
                                " doesn't fit to bus: " <<
                                progMove.bus().name();
 
                            throw NotAvailable(
                                __FILE__, __LINE__, __func__, message);
                        }   
                        
                        if (progMove.bus().signExtends()) {
                            newImmediate->setSignedLong(wordToStore);
                        } else {
                            newImmediate->setULongWord(wordToStore);
                        }
                        newImmediate->setDestinationUnit(
                            ResourceElement::INLINE_IMM);
                        newImmediate->setDestinationIndex(immediateIndex);
                        immediateIndex++;
 
                        code->addElement(newImmediate);
 
                        tpefMove->setSourceType(MoveElement::MF_IMM);
                        tpefMove->setSourceUnit(
                            newImmediate->destinationUnit());
                        tpefMove->setSourceIndex(
                            newImmediate->destinationIndex());
 
                        // add relocation antries if needed
                        if (progMove.source().isInstructionAddress()) {
                            
                            // TODO: check size of inline immediate field
                            RelocInfo newReloc(
                                code, newImmediate, 
                                progMove.source().address(),
                                IMMEDIATE_ADDRESS_WIDTH);
                            
                            relocInfos_.push_back(newReloc);
                            
                        } else if (progMove.source().isAddress()) {
 
                            // TODO: check size of inline immediate field
                            RelocInfo newReloc(
                                code, newImmediate, 
                                progMove.source().address(),
                                IMMEDIATE_ADDRESS_WIDTH);
 
                            relocInfos_.push_back(newReloc);
 
                        }
                    }
 
                    // set destination
                    ResourceID destinationId =
                        terminalResource(progMove.destination(), updater);
#if 0
                    std::cerr << "dst type: " << destinationId.type
                              << "\tunit: " << destinationId.unit
                              << "\tindex: " << destinationId.index
                              << std::endl;
#endif
                    tpefMove->setDestinationType(destinationId.type);
                    tpefMove->setDestinationUnit(destinationId.unit);
                    tpefMove->setDestinationIndex(destinationId.index);
 
                    // set guard stuff
                    if (progMove.isUnconditional()) {
                        tpefMove->setGuarded(false);
                    } else {
 
                        const Guard *guard = &progMove.guard().guard();
 
                        tpefMove->setGuarded(true);
 
                        tpefMove->setGuardInverted(guard->isInverted());
 
                        const PortGuard *portGuard =
                            dynamic_cast<const PortGuard*>(guard);
                        const RegisterGuard *registerGuard =
                            dynamic_cast<const RegisterGuard*>(guard);
 
                        if (portGuard != NULL) {
                            tpefMove->setGuardType(MoveElement::MF_UNIT);
 
                            FunctionUnit &funcUnit = 
                                *portGuard->port()->parentUnit();
 
                            ResourceElement &fu = 
                                updater.functionUnit(funcUnit);
                            tpefMove->setGuardUnit(fu.id());
 
                            // is operation or special register port
                            FunctionUnit *parentFu =
                                portGuard->port()->parentUnit();
 
                            const FUPort *fuPort = portGuard->port();
 
                            if (parentFu->hasOperationPort(fuPort->name())) {
                                HWOperation *oper = NULL;
 
                                // find just any operation that is 
                                // bound to guarded port
                                for (int i = 0; 
                                     i < parentFu->operationCount(); i++) {
                                    oper = parentFu->operation(i);
 
                                    if (oper->isBound(*fuPort)) {
                                        break;
                                    }
 
                                    oper = NULL;
                                }
 
                                assert(oper != NULL);
 
                                ResourceElement &opPort =
                                    updater.operand(
                                        *oper, oper->io(*fuPort));
 
                                tpefMove->setGuardIndex(opPort.id());
 
                            } else {
                                ResourceElement &fuPortResource =
                                    updater.functionUnitPort(*fuPort);
 
                                tpefMove->setGuardIndex(fuPortResource.id());
                            }
 
                        } else if (registerGuard != NULL) {
                            tpefMove->setGuardType(MoveElement::MF_RF);
 
                            const RegisterFile &regFile =
                                *registerGuard->registerFile();
 
                            ResourceElement &rf = 
                                updater.registerFile(regFile);
 
                            tpefMove->setGuardUnit(rf.id());
 
                            tpefMove->setGuardIndex(
                                registerGuard->registerIndex());
 
                        } else {
                            abortWithError("Unknown machine guard type.");
                        }
                    }
                }
            }
 
            // write long immediates
            for (int k = 0; k < currInstr.immediateCount(); k++) {
                Immediate& imm = currInstr.immediate(k);
 
                ImmediateElement* tpefImm = new ImmediateElement();
 
                tpefImm->setBegin(beginFlag);
                beginFlag = false;
 
                if (imm.destination().immediateUnit().signExtends()) {
                    tpefImm->setSignedLong(imm.value().value().sLongWordValue());
                } else {
                    tpefImm->setULongWord(imm.value().value().uLongWordValue());
                }
 
                ResourceID dstRes =
                    terminalResource(imm.destination(), updater);
 
                tpefImm->setDestinationUnit(dstRes.unit);
                tpefImm->setDestinationIndex(dstRes.index);
 
                code->addElement(tpefImm);
 
                // add relocation antries if needed
                if (imm.value().isInstructionAddress()) {
                    
                    // TODO: check size of long immediate field
                    RelocInfo newReloc(
                        code, tpefImm, 
                        imm.value().address(),
                        IMMEDIATE_ADDRESS_WIDTH);
                    
                    relocInfos_.push_back(newReloc);
 
                } else if (imm.value().isAddress()) {
                            
                    // TODO: check size of long immediate field
                    RelocInfo newReloc(
                        code, tpefImm, 
                        imm.value().address(),
                        IMMEDIATE_ADDRESS_WIDTH);
                    
                    relocInfos_.push_back(newReloc);
 
                }
            }
 
            // add empty instruction (instruction containing one empty move)
            if (currInstr.moveCount() == 0 &&
                currInstr.immediateCount() == 0) {
 
                MoveElement *tpefNOP = new MoveElement();
                tpefNOP->setBegin(true);
                tpefNOP->setEmpty(true);
 
                if (currInstr.hasAnnotations()) {
                    for (int annotationIndex = 0;
                         annotationIndex < currInstr.annotationCount();
                         ++annotationIndex) {
                        const ProgramAnnotation& annot =
                            currInstr.annotation(annotationIndex);
                        tpefNOP->addAnnotation(
                            new InstructionAnnotation(
                                annot.id(), annot.payload()));
                    }
                }
                code->addElement(tpefNOP);
            }
        }
    }
}

References __func__, abortWithError, TPEF::InstructionElement::addAnnotation(), TPEF::CodeSection::addElement(), TTAProgram::Instruction::address(), TTAProgram::Terminal::address(), TTAProgram::AnnotatedInstructionElement::annotation(), TTAProgram::AnnotatedInstructionElement::annotationCount(), assert, TTAProgram::Move::bus(), TTAProgram::TPEFResourceUpdater::bus(), TTAMachine::Machine::busNavigator(), TTAProgram::Immediate::destination(), TTAProgram::Move::destination(), TPEF::ImmediateElement::destinationIndex(), TPEF::ImmediateElement::destinationUnit(), POMDisassembler::disassemble(), TTAProgram::TPEFResourceUpdater::functionUnit(), TTAProgram::TPEFResourceUpdater::functionUnitPort(), TTAProgram::Move::guard(), TTAProgram::MoveGuard::guard(), TTAProgram::AnnotatedInstructionElement::hasAnnotations(), TTAMachine::FunctionUnit::hasOperationPort(), TTAProgram::ProgramAnnotation::id(), TPEF::ResourceElement::id(), TTAProgram::Instruction::immediate(), IMMEDIATE_ADDRESS_WIDTH, TTAProgram::Instruction::immediateCount(), TTAProgram::Terminal::immediateUnit(), TTAMachine::Bus::immediateWidth(), TTAProgram::ProgramWriter::ResourceID::index, TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), TTAMachine::HWOperation::io(), TTAProgram::Terminal::isAddress(), TTAMachine::HWOperation::isBound(), TPEF::MoveElement::isEmpty(), TTAProgram::Terminal::isImmediate(), TTAProgram::Terminal::isInstructionAddress(), TTAMachine::Guard::isInverted(), TTAProgram::Move::isUnconditional(), TTAProgram::Address::location(), MAX_SIMM_WIDTH, TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), TTAMachine::Component::name(), TTAMachine::Port::name(), TTAProgram::Procedure::name(), TTAProgram::TPEFResourceUpdater::operand(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), TTAProgram::Move::parent(), TTAMachine::BaseFUPort::parentUnit(), TTAProgram::ProgramAnnotation::payload(), TTAMachine::PortGuard::port(), TTAProgram::Program::procedure(), TTAProgram::Program::procedureCount(), prog_, TTAMachine::RegisterGuard::registerFile(), TTAProgram::TPEFResourceUpdater::registerFile(), TTAMachine::RegisterGuard::registerIndex(), relocInfos_, MathTools::requiredBits(), MathTools::requiredBitsSigned(), TPEF::InstructionElement::setBegin(), TPEF::MoveElement::setBus(), 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::ImmediateElement::setSignedLong(), TPEF::MoveElement::setSourceIndex(), TPEF::MoveElement::setSourceType(), TPEF::MoveElement::setSourceUnit(), TPEF::Section::setStartingAddress(), TPEF::ImmediateElement::setULongWord(), TTAMachine::Bus::signExtends(), TTAMachine::ImmediateUnit::signExtends(), MathTools::signExtendTo(), SimValue::sLongWordValue(), TTAProgram::Move::source(), TTAProgram::Program::startAddress(), TTAProgram::Program::targetProcessor(), terminalResource(), Conversion::toString(), TTAProgram::ProgramWriter::ResourceID::type, SimValue::uLongWordValue(), TTAProgram::ProgramWriter::ResourceID::unit, SimValue::unsignedValue(), TTAProgram::Immediate::value(), TTAProgram::Terminal::value(), TTAProgram::TerminalImmediate::value(), and MathTools::zeroExtendTo().

Referenced by createBinary().

createDataSections()

void TTAProgram::ProgramWriter::createDataSections ( TPEF::Binary *  bin, bool  littleEndian  ) const

private

Creates data section to TPEF.

Parameters

bin	Binary to write the sections to.

Definition at line 1403 of file ProgramWriter.cc.

                                                                      {
    
    std::map<AddressSpace*, ASpaceElement*> aSpaceMap;
 
    ASpaceSection* aSpaceSection = dynamic_cast<ASpaceSection*>(
        bin->section(Section::ST_ADDRSP, 0));
 
    StringSection* strings =
        dynamic_cast<StringSection*>(aSpaceSection->link());
    
    // go through all the DataMemories of POM
    for (int i = 0; i < prog_.dataMemoryCount(); i++) {
        DataMemory& currMem = prog_.dataMemory(i);        
 
        UDataSection* currSect = NULL;    
 
        for (int j = 0; j < currMem.dataDefinitionCount(); j++) {
            DataDefinition& currDef = currMem.dataDefinition(j);
 
            assert(&currDef.startAddress().space() == 
                   &currMem.addressSpace());
            
            // create new data dection if needed
            if (currSect == NULL ||
                
                (currDef.isInitialized() && 
                 !currSect->isDataSection()) ||
                
                (!currDef.isInitialized() && 
                 currSect->isDataSection()) ||
                
                (currDef.startAddress().location() !=
                 currSect->startingAddress() +
                 currSect->lengthInMAUs())) {
                
                if (currDef.isInitialized()) {
                    if (!littleEndian) {
                        currSect = dynamic_cast<DataSection*>(
                            Section::createSection(Section::ST_DATA));
                    } else {
                        currSect = dynamic_cast<DataSection*>(
                            Section::createSection(Section::ST_LEDATA));
                    }
                } else {
                    currSect = dynamic_cast<UDataSection*>(
                        Section::createSection(Section::ST_UDATA));
                }
               
                // add section to binary
                assert (currSect != NULL);
                bin->addSection(currSect);
                
                currSect->setStartingAddress(
                    currDef.startAddress().location());                
 
                currSect->setName(strings->string2Chunk(""));                
                
                currSect->setLink(bin->section(Section::ST_NULL,0));
                
                const AddressSpace& adfASpace =  currMem.addressSpace();
                currSect->setASpace(&createASpaceElement(adfASpace, *bin));
            }
            
            // add data to section
            if (currDef.isInitialized()) {
                DataSection* dataSect = dynamic_cast<DataSection*>(currSect);
                
                int byteOffset = dataSect->length();
                
                for (int k = 0; k < currDef.size(); k++) {
                    dataSect->addMAU(currDef.MAU(k));
                }
                
                if (currDef.isAddress()) {
                    RelocInfo newReloc(
                        dataSect, dataSect->chunk(byteOffset),
                        currDef.destinationAddress(),
                        currDef.size() * dataSect->aSpace()->MAU());
 
                    relocInfos_.push_back(newReloc);
                }
                
            } else {
                currSect->setLengthInMAUs(
                    currSect->lengthInMAUs() + currDef.size());
            }
 
 
#if 0
            // Prints debug data of all encountered data definitions.
            if (currSect != NULL) {
                Application::logStream()
                    << "datadef: addr: " 
                    << currDef.startAddress().space().name() << ":"
                    << currDef.startAddress().location()
                    << "\t" << "size: " << currDef.size()
                    << "\t" << "init: " << currDef.isInitialized()
                    << "\t" << "isAddr: " << currDef.isAddress();
                if (currDef.isAddress()) {
                    Application::logStream()
                        << "\t" << "dest: "
                        << currDef.destinationAddress().space().name() << ":"
                        << currDef.destinationAddress().location();
                }
                Application::logStream()
                    << std::endl;
            }
#endif
 
#if 0
            // prints out debug data of all created data sections
            if (currSect != NULL) {
                DataSection* dSectTmp = dynamic_cast<DataSection*>(currSect);
                Application::logStream()
                    << "data section " << currSect << " length: " 
                    << currSect->lengthInMAUs()
                    << "\tstart address: " 
                    << TPEFTools::addressSpaceName(
                        *bin, *currSect->aSpace())
                    << ":" << currSect->startingAddress()
                    << "\tinitialized: " 
                    // << static_cast<int>(currSect->isDataSection())
                    << (dSectTmp?true:false)
                    << std::endl;
            }
#endif
 
        }
    }
}

References TPEF::DataSection::addMAU(), TTAProgram::DataMemory::addressSpace(), TPEF::Binary::addSection(), TPEF::Section::aSpace(), assert, TPEF::RawSection::chunk(), createASpaceElement(), TTAProgram::DataMemory::dataDefinition(), TTAProgram::DataMemory::dataDefinitionCount(), TTAProgram::Program::dataMemory(), TTAProgram::Program::dataMemoryCount(), TTAProgram::DataDefinition::destinationAddress(), TTAProgram::DataDefinition::isAddress(), TPEF::Section::isDataSection(), TTAProgram::DataDefinition::isInitialized(), TPEF::DataSection::length(), TPEF::RawSection::lengthInMAUs(), TPEF::Section::link(), TTAProgram::Address::location(), Application::logStream(), TPEF::ASpaceElement::MAU(), TTAProgram::DataDefinition::MAU(), TTAMachine::Component::name(), prog_, relocInfos_, TPEF::Binary::section(), TPEF::Section::setASpace(), TPEF::RawSection::setLengthInMAUs(), TPEF::Section::setLink(), TPEF::Section::setName(), TPEF::Section::setStartingAddress(), TTAProgram::DataDefinition::size(), TTAProgram::Address::space(), TTAProgram::DataDefinition::startAddress(), TPEF::Section::startingAddress(), and TPEF::StringSection::string2Chunk().

Referenced by createBinary().

Here is the call graph for this function:

createRelocSections()

void TTAProgram::ProgramWriter::createRelocSections ( TPEF::Binary *  bin ) const

private

Create relocation tables to binary and add relocation elements.

Parameters

bin	Binary where to add relocation sections.

Exceptions

NotAvailable

Can't find needed resource.

Definition at line 1578 of file ProgramWriter.cc.

                                                        {
    StringSection* strings = dynamic_cast<StringSection*>(
        bin->section(Section::ST_STRTAB,0));
 
    ASpaceSection* aSpaces = dynamic_cast<ASpaceSection*>(
        bin->section(Section::ST_ADDRSP,0));
 
    SymbolSection* symbols = dynamic_cast<SymbolSection*>(
        bin->section(Section::ST_SYMTAB, 0));
    
    RelocSection* currRelocs = NULL;
    
    for (int i = 0; i < static_cast<int>(relocInfos_.size()); i++) {
        RelocInfo& currReloc = relocInfos_[i];
        
        Section& dstSect = findSection(*bin, currReloc.destination);
        
        // create new reloc section if needed
        if (currRelocs == NULL || 
            currRelocs->referencedSection() != currReloc.srcSect) {
 
            currRelocs = dynamic_cast<RelocSection*>(
                Section::createSection(Section::ST_RELOC));            
            bin->addSection(currRelocs);
 
            currRelocs->setName(strings->string2Chunk(""));         
            currRelocs->setLink(symbols);
            currRelocs->setASpace(aSpaces->undefinedASpace());
            currRelocs->setReferencedSection(currReloc.srcSect);
        }
 
        SectionElement* dstElem = NULL;
 
        // get element by address (destination element)
        if (dstSect.isCodeSection()) {
            CodeSection& codeSect = 
                dynamic_cast<CodeSection&>(dstSect);
            
            dstElem = &codeSect.instruction(
                currReloc.destination.location() - 
                codeSect.startingAddress());
            
        } else {
            UDataSection& dataSect = 
                dynamic_cast<UDataSection&>(dstSect);
            
            int byteOffset = dataSect.MAUsToBytes(
                currReloc.destination.location() - 
                dataSect.startingAddress());
            
            dstElem = dataSect.chunk(byteOffset);
        }
 
        RelocElement* newReloc = new RelocElement();
        currRelocs->addElement(newReloc);
 
        newReloc->setType(RelocElement::RT_SELF);
        
        newReloc->setLocation(currReloc.srcElem);
 
        newReloc->setDestination(dstElem);
 
        newReloc->setSymbol(
            dynamic_cast<SymbolElement*>(symbols->element(0)));
 
        newReloc->setASpace(
            &createASpaceElement(
                currReloc.destination.space(), *bin));
        
        newReloc->setSize(currReloc.bits);
        
    }
}

References TPEF::Section::addElement(), TPEF::Binary::addSection(), TTAProgram::ProgramWriter::RelocInfo::bits, TPEF::RawSection::chunk(), createASpaceElement(), TTAProgram::ProgramWriter::RelocInfo::destination, TPEF::Section::element(), findSection(), TPEF::CodeSection::instruction(), TPEF::Section::isCodeSection(), TTAProgram::Address::location(), TPEF::RawSection::MAUsToBytes(), TPEF::RelocSection::referencedSection(), relocInfos_, TPEF::Binary::section(), TPEF::RelocElement::setASpace(), TPEF::Section::setASpace(), TPEF::RelocElement::setDestination(), TPEF::Section::setLink(), TPEF::RelocElement::setLocation(), TPEF::Section::setName(), TPEF::RelocSection::setReferencedSection(), TPEF::RelocElement::setSize(), TPEF::RelocElement::setSymbol(), TPEF::RelocElement::setType(), TTAProgram::Address::space(), TTAProgram::ProgramWriter::RelocInfo::srcElem, TTAProgram::ProgramWriter::RelocInfo::srcSect, TPEF::Section::startingAddress(), TPEF::StringSection::string2Chunk(), and TPEF::ASpaceSection::undefinedASpace().

Referenced by createBinary().

Here is the call graph for this function:

findSection()

TPEF::Section & TTAProgram::ProgramWriter::findSection ( TPEF::Binary &  bin, Address  address  ) const

private

Finds section which contain requested address.

Parameters

bin	TPEF where from sections are searched.
address	The address that are looked for.

Returns

The section which contains requested address.

Definition at line 1660 of file ProgramWriter.cc.

                                                             {
 
    for (int i = 0; i < static_cast<int>(bin.sectionCount()); i++) {
        Section& currSect = *bin.section(i);
 
        if (currSect.isProgramSection()) {
            if (currSect.startingAddress() <= address.location() && 
                &createASpaceElement(address.space(), bin) == 
                currSect.aSpace()) {
                
                if (currSect.isCodeSection()) {
                    CodeSection& codeSect = 
                        dynamic_cast<CodeSection&>(currSect);
 
                    if (codeSect.instructionCount() +
                        codeSect.startingAddress() > address.location()) {
                        
                        return codeSect;
                    }
                } else {
                    UDataSection& dataSect = 
                        dynamic_cast<UDataSection&>(currSect);
                    
                    if (dataSect.startingAddress() +
                        dataSect.lengthInMAUs() > address.location()) {
                        
                        return dataSect;
                    }
                }
            }
        }
    }
    
    throw NotAvailable(
        __FILE__, __LINE__, __func__,
        "Can't find section containing address: " + address.space().name() +
        ":" + Conversion::toString(address.location()));
}

References __func__, TPEF::Section::aSpace(), createASpaceElement(), TPEF::CodeSection::instructionCount(), TPEF::Section::isCodeSection(), TPEF::Section::isProgramSection(), TPEF::RawSection::lengthInMAUs(), TTAProgram::Address::location(), TTAMachine::Component::name(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), TTAProgram::Address::space(), TPEF::Section::startingAddress(), and Conversion::toString().

Referenced by createRelocSections().

Here is the call graph for this function:

resolveFileType()

TPEF::Binary::FileType TTAProgram::ProgramWriter::resolveFileType ( TPEF::ResourceSection &  resources ) const

private

Find out the kind of TPEF file type.

This method scans the resource section and checks the type of processor resource elements it contains. Based on their types, it figures out what should be the file type.

Parameters

resources

Resource section.

Returns

File type of TPEF binary.

Definition at line 1711 of file ProgramWriter.cc.

                                                                   {
 
    bool univRefs = false;
    bool realRefs = false;
 
    for (unsigned int i = 0; i < resources.elementCount(); i++) {
        ResourceElement* res =
            dynamic_cast<ResourceElement*>(resources.element(i));
 
        switch(res->type()) {
 
        case ResourceElement::MRT_BUS:
            if (res->id() == ResourceElement::UNIVERSAL_BUS) {
                univRefs = true;
            } else {
                realRefs = true;
            }
            break;
 
        case ResourceElement::MRT_UNIT:
            if (res->id() == ResourceElement::UNIVERSAL_FU) {
                univRefs = true;
            } else {
                realRefs = true;
            }
            break;
 
        case ResourceElement::MRT_RF:
            if (res->id() == ResourceElement::INT_RF ||
                res->id() == ResourceElement::BOOL_RF ||
                res->id() == ResourceElement::FP_RF) {
                univRefs = true;
            } else {
                realRefs = true;
            }
            break;
 
        case ResourceElement::MRT_IMM:
            realRefs = true;
            break;
 
        default:
            ;// just omit MRT_PORT, MRT_SR and MRT_OP
        }
    }
 
    if (univRefs && realRefs) {
        return Binary::FT_MIXED;
    } else if (univRefs) {
        return Binary::FT_PURESEQ;
    } else if (!univRefs && realRefs) {
        return Binary::FT_PARALLEL;
    }
 
    return Binary::FT_NULL;
}

References TPEF::Section::element(), TPEF::Section::elementCount(), TPEF::ResourceElement::id(), and TPEF::ResourceElement::type().

Referenced by createBinary().

Here is the call graph for this function:

terminalResource()

ProgramWriter::ResourceID TTAProgram::ProgramWriter::terminalResource ( const Terminal &  term, TPEFResourceUpdater &  updater  ) const

private

Finds out resource element and index by terminal.

Parameters

term	Terminal whose TPEF resource information is needed.
updater	Resource updater for finding TPEF resources.

Definition at line 1310 of file ProgramWriter.cc.

                                        {
 
    ResourceID retVal;
    retVal.type = MoveElement::MF_RF;
    retVal.unit = 0;
    retVal.index = 0;
    
    try {
 
        if (term.isImmediate()) {
            abortWithError(
                "This function should never be called with ImmediateTerminal "
                " instance type.");
 
        } else if (term.isGPR()) {
            retVal.type = MoveElement::MF_RF;
            retVal.unit = updater.registerFile(term.registerFile()).id();
            retVal.index = term.index();
 
        } else if (term.isImmediateRegister()) {
            retVal.type = MoveElement::MF_IMM;
            retVal.unit = updater.immediateUnit(term.immediateUnit()).id();
            retVal.index = term.index();
 
        }  else if (term.isFUPort()) {
 
            retVal.type = MoveElement::MF_UNIT;
 
            FunctionUnit &fu =
                *dynamic_cast<FunctionUnit*>(term.port().parentUnit());
 
            retVal.unit = updater.functionUnit(fu).id();
 
            const TerminalFUPort& fuTerm =
                dynamic_cast<const TerminalFUPort&>(term);
 
            // find if there is information of operation in terminal
            if (&fuTerm.hintOperation() != &NullOperation::instance() ||
                fuTerm.isOpcodeSetting()) {
 
                std::string operationName =
                    (fuTerm.isOpcodeSetting()) ?
                    (fuTerm.operation().name()) :
                    (fuTerm.hintOperation().name());
 
                if (fu.hasOperation(operationName)) {
                    HWOperation *oper = fu.operation(operationName);
 
                    int index = oper->io(
                        dynamic_cast<const FUPort&>(term.port()));
 
                    retVal.index = updater.operand(*oper, index).id();
 
                } else {
                    abortWithError(
                        "Can't find operation " + operationName +
                        " from FU: " + fu.name());
                }
 
            } else {
                // not opcode setting normal fu port without operation hint
                assert(!fuTerm.isOpcodeSetting());
                ResourceElement &fuPort = 
                    updater.functionUnitPort(term.port());
                retVal.index = fuPort.id();
            }
 
        } else {
            abortWithError("Unknown terminal type.");
        }
 
    } catch (const InvalidData& e) {
        NotAvailable error(__FILE__, __LINE__, __func__,
                           "Problems with finding terminal: " + 
                           e.errorMessage());
 
        error.setCause(e);
 
        throw error;
    } 
 
    return retVal;
}

References __func__, abortWithError, assert, Exception::errorMessage(), TTAProgram::TPEFResourceUpdater::functionUnit(), TTAProgram::TPEFResourceUpdater::functionUnitPort(), TTAMachine::FunctionUnit::hasOperation(), TTAProgram::TerminalFUPort::hintOperation(), TPEF::ResourceElement::id(), TTAProgram::Terminal::immediateUnit(), TTAProgram::TPEFResourceUpdater::immediateUnit(), TTAProgram::ProgramWriter::ResourceID::index, TTAProgram::Terminal::index(), NullOperation::instance(), TTAMachine::HWOperation::io(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isGPR(), TTAProgram::Terminal::isImmediate(), TTAProgram::Terminal::isImmediateRegister(), TTAProgram::TerminalFUPort::isOpcodeSetting(), TTAMachine::Component::name(), Operation::name(), TTAProgram::TPEFResourceUpdater::operand(), TTAProgram::TerminalFUPort::operation(), TTAMachine::FunctionUnit::operation(), TTAMachine::Port::parentUnit(), TTAProgram::Terminal::port(), TTAProgram::Terminal::registerFile(), TTAProgram::TPEFResourceUpdater::registerFile(), Exception::setCause(), TTAProgram::ProgramWriter::ResourceID::type, and TTAProgram::ProgramWriter::ResourceID::unit.

Referenced by createCodeSection().

Here is the call graph for this function:

Member Data Documentation

aSpaceMap_

std::map<const TTAMachine::AddressSpace*, TPEF::ASpaceElement*> TTAProgram::ProgramWriter::aSpaceMap_

mutableprivate

Created TPEF binary.

Map that contains created address spaces

Definition at line 209 of file ProgramWriter.hh.

Referenced by createASpaceElement(), and createBinary().

IMMEDIATE_ADDRESS_WIDTH

const HalfWord TTAProgram::ProgramWriter::IMMEDIATE_ADDRESS_WIDTH = WORD_BITWIDTH

staticprivate

Default widt that is used as address width of relocations of immediate elements. This should be fixed by checking width from bus or template.

Definition at line 215 of file ProgramWriter.hh.

Referenced by createCodeSection().

MAX_SIMM_WIDTH

const int TTAProgram::ProgramWriter::MAX_SIMM_WIDTH = 64

staticprivate

Maximum width for short immediates.

Definition at line 218 of file ProgramWriter.hh.

Referenced by createCodeSection().

prog_

const Program& TTAProgram::ProgramWriter::prog_

private

Program that is written to TPEF.

Definition at line 203 of file ProgramWriter.hh.

Referenced by createASpaceElement(), createBinary(), createCodeSection(), and createDataSections().

relocInfos_

std::vector<RelocInfo> TTAProgram::ProgramWriter::relocInfos_

mutableprivate

Definition at line 211 of file ProgramWriter.hh.

Referenced by createBinary(), createCodeSection(), createDataSections(), and createRelocSections().

---

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

• ProgramWriter.hh
• ProgramWriter.cc