TPEF::TPEFCodeSectionWriter Class Reference

#include <TPEFCodeSectionWriter.hh>

Inheritance diagram for TPEF::TPEFCodeSectionWriter:

Collaboration diagram for TPEF::TPEFCodeSectionWriter:

Protected Member Functions
	TPEFCodeSectionWriter ()
virtual	~TPEFCodeSectionWriter ()
virtual Section::SectionType	type () const
virtual void	actualWriteData (BinaryStream &stream, const Section *sect) const
virtual void	writeInfo (BinaryStream &stream, const Section *sect) const
virtual void	writeId (BinaryStream &stream, HalfWord id) const
Protected Member Functions inherited from TPEF::TPEFSectionWriter
	TPEFSectionWriter ()
virtual	~TPEFSectionWriter ()
virtual const BinaryWriter &	parent () const
virtual void	actualWriteHeader (BinaryStream &stream, const Section *sect) const
virtual void	createKeys (const Section *sect) const
virtual void	writeSize (BinaryStream &stream, const Section *sect) const
virtual SectionId	getSectionId () const
virtual Word	elementSize (const Section *section) const
Protected Member Functions inherited from TPEF::SectionWriter
	SectionWriter ()
virtual	~SectionWriter ()
virtual void	finalize (BinaryStream &stream, Section *section) const

Private Member Functions
	TPEFCodeSectionWriter (const TPEFCodeSectionWriter &)
	Copying not allowed.
TPEFCodeSectionWriter &	operator= (const TPEFCodeSectionWriter &)
	Assignment not allowed.
void	writeAttributeField (BinaryStream &stream, SectionElement *elem, bool isEnd) const
void	writeDataField (BinaryStream &stream, SectionElement *elem) const
void	writeAnnotations (BinaryStream &stream, SectionElement *elem) const

Static Private Attributes
static const TPEFCodeSectionWriter	instance_
	Unique instance of class.
static const Byte	IMMEDIATE_VALUE_MAX_BYTES = 16
	Maximum number of bytes that single immediate can contain.

Additional Inherited Members
Static Public Member Functions inherited from TPEF::SectionWriter
static void	writeHeader (BinaryStream &stream, const Section *sect, const BinaryWriter *writer)
static void	writeData (BinaryStream &stream, const Section *sect, const BinaryWriter *writer)
static void	finalizeBinary (BinaryStream &stream, const Binary *binaryToFinalize, const BinaryWriter *writer)
Static Protected Member Functions inherited from TPEF::SectionWriter
static void	registerSectionWriter (const SectionWriter *sWriter)
static SectionId	getUniqueSectionId ()

Detailed Description

Writes TPEF code section to file.

Definition at line 48 of file TPEFCodeSectionWriter.hh.

Constructor & Destructor Documentation

TPEFCodeSectionWriter() [1/2]

TPEF::TPEFCodeSectionWriter::TPEFCodeSectionWriter ( )

protected

Constructor.

Registers itself to SectionWriter.

Definition at line 64 of file TPEFCodeSectionWriter.cc.

                                             : TPEFSectionWriter() {
    registerSectionWriter(this);
}

References TPEF::SectionWriter::registerSectionWriter().

Here is the call graph for this function:

~TPEFCodeSectionWriter()

TPEF::TPEFCodeSectionWriter::~TPEFCodeSectionWriter ( )

protectedvirtual

Destructor.

Definition at line 71 of file TPEFCodeSectionWriter.cc.

                                              {
}

TPEFCodeSectionWriter() [2/2]

TPEF::TPEFCodeSectionWriter::TPEFCodeSectionWriter ( const TPEFCodeSectionWriter &  )

private

Copying not allowed.

Member Function Documentation

actualWriteData()

void TPEF::TPEFCodeSectionWriter::actualWriteData ( BinaryStream &  stream, const Section *  sect  ) const

protectedvirtual

Writes the data of the section to stream.

Parameters

stream	The stream to be written to.
sect	The section to be written.

Reimplemented from TPEF::TPEFSectionWriter.

Definition at line 91 of file TPEFCodeSectionWriter.cc.

                               {
 
    // file offset to data of section
    FileOffset startOffset = stream.writePosition();
 
    SectionOffset sectOffset = 0;
 
    SectionKey sKey = SafePointer::sectionKeyFor(sect);
    SectionId id = sKey.sectionId();
 
    for (Word i = 0; i < sect->elementCount(); i++) {
        InstructionElement *elem =
            dynamic_cast<InstructionElement*>(sect->element(i));
 
        assert(elem != NULL);
 
        sectOffset = stream.writePosition() - startOffset;
 
        if (SafePointer::isReferenced(elem) || i == 0) {
            SafePointer::addObjectReference(
                SectionOffsetKey(id, sectOffset), elem);
        }
 
        // check if this is ending move of instruction
        bool isEnd = false;
        i++;
        if (i == sect->elementCount() ||
            dynamic_cast<InstructionElement*>(sect->element(i))->begin()) {
 
            isEnd = true;
        }
        i--;
 
        writeAttributeField(stream, elem, isEnd);
        writeDataField(stream, elem);
        writeAnnotations(stream, elem);
    }
 
    // section body offset
    SafePointer::addObjectReference(
        FileOffsetKey(startOffset), sect->element(0));
 
    SectionSizeReplacer::setSize(sect, stream.writePosition() - startOffset);
}

References TPEF::ReferenceManager::SafePointer::addObjectReference(), assert, TPEF::InstructionElement::begin(), TPEF::Section::element(), TPEF::Section::elementCount(), TPEF::ReferenceManager::SafePointer::isReferenced(), TPEF::ReferenceManager::SectionKey::sectionId(), TPEF::ReferenceManager::SafePointer::sectionKeyFor(), TPEF::SectionSizeReplacer::setSize(), writeAnnotations(), writeAttributeField(), writeDataField(), and TPEF::BinaryStream::writePosition().

Here is the call graph for this function:

operator=()

TPEFCodeSectionWriter & TPEF::TPEFCodeSectionWriter::operator= ( const TPEFCodeSectionWriter &  )

private

Assignment not allowed.

type()

Section::SectionType TPEF::TPEFCodeSectionWriter::type ( ) const

protectedvirtual

Returns the type of section that this writer writes.

Returns

The type of section that this writer writes.

Implements TPEF::TPEFSectionWriter.

Definition at line 80 of file TPEFCodeSectionWriter.cc.

                                  {
    return Section::ST_CODE;
}

References TPEF::Section::ST_CODE.

writeAnnotations()

void TPEF::TPEFCodeSectionWriter::writeAnnotations ( BinaryStream &  stream, SectionElement *  elem  ) const

private

Writes annotations to stream if there are any.

Parameters

stream	Stream to write.
elem	Element, whose annotations are written.

Definition at line 304 of file TPEFCodeSectionWriter.cc.

                                {
 
    InstructionElement *instr = dynamic_cast<InstructionElement*>(elem);
 
    for (Word i = 0; i < instr->annotationCount(); i++) {
 
        InstructionAnnotation* annotation = instr->annotation(i);
 
        Byte sizeAndContinuation =
            annotation->size() & TPEFHeaders::IANNOTE_SIZE;
 
        // if not last annotation
        if (i != (instr->annotationCount() - 1)) {
            sizeAndContinuation =
                sizeAndContinuation | TPEFHeaders::IANNOTE_CONTINUATION;
        }
 
        stream.writeByte(sizeAndContinuation);
 
        // write identification code in big endian format
        // NOTE: should there be function in
        //       BinaryStream to write 3 byte "word"s?
        stream.writeByte(annotation->id() & 0xff);
        stream.writeByte((annotation->id() >> (BYTE_BITWIDTH)) & 0xff);
        stream.writeByte((annotation->id() >> (BYTE_BITWIDTH*2)) & 0xff);
 
        // write payload
        for (Word j = 0; j < annotation->size(); j++) {
            stream.writeByte(annotation->byte(j));
        }
    }
}

References TPEF::InstructionElement::annotation(), TPEF::InstructionElement::annotationCount(), TPEF::InstructionAnnotation::byte(), BYTE_BITWIDTH, TPEF::TPEFHeaders::IANNOTE_CONTINUATION, TPEF::TPEFHeaders::IANNOTE_SIZE, TPEF::InstructionAnnotation::id(), TPEF::InstructionAnnotation::size(), and TPEF::BinaryStream::writeByte().

Referenced by actualWriteData().

Here is the call graph for this function:

writeAttributeField()

void TPEF::TPEFCodeSectionWriter::writeAttributeField ( BinaryStream &  stream, SectionElement *  elem, bool  isEnd  ) const

private

Writes the attribute field of either move or immediate.

Parameters

stream	The stream to be written to.
elem	The element to be written out.

Definition at line 145 of file TPEFCodeSectionWriter.cc.

                      {
 
    Byte attribute = 0;
 
    if (dynamic_cast<InstructionElement*>(elem)->isMove()) {
 
        MoveElement* move = dynamic_cast<MoveElement*>(elem);
 
        if (move->isGuarded()) {
            attribute = attribute | TPEFHeaders::IA_MGUARD;
        }
 
        if (move->isEmpty()) {
            attribute = attribute | TPEFHeaders::IA_EMPTY;
        }
 
    } else if (dynamic_cast<InstructionElement*>(elem)->isImmediate()) {
 
        ImmediateElement* imm = dynamic_cast<ImmediateElement*>(elem);
 
        // immediate type flag
        attribute = attribute |  TPEFHeaders::IA_TYPE;
 
        // length of immediate is stored in 4 first bits of byte.
        Byte immLength = imm->length();
        Byte immBits = (immLength << (BYTE_BITWIDTH / 2));
 
        attribute = attribute | immBits;
 
    } else {
        bool impossibleInstructionElementType = false;
        assert(impossibleInstructionElementType);
    }
 
    if (dynamic_cast<InstructionElement*>(elem)->annotationCount() > 0) {
        attribute = attribute |  TPEFHeaders::IA_ANNOTE;
    }
 
    if (isEnd) {
        attribute = attribute |  TPEFHeaders::IA_END;
    }
 
    stream.writeByte(attribute);
}

References assert, BYTE_BITWIDTH, TPEF::TPEFHeaders::IA_ANNOTE, TPEF::TPEFHeaders::IA_EMPTY, TPEF::TPEFHeaders::IA_END, TPEF::TPEFHeaders::IA_MGUARD, TPEF::TPEFHeaders::IA_TYPE, TPEF::MoveElement::isEmpty(), TPEF::MoveElement::isGuarded(), TPEF::InstructionElement::isImmediate(), TPEF::ImmediateElement::length(), and TPEF::BinaryStream::writeByte().

Referenced by actualWriteData().

Here is the call graph for this function:

writeDataField()

void TPEF::TPEFCodeSectionWriter::writeDataField ( BinaryStream &  stream, SectionElement *  elem  ) const

private

Writes the data portion of either move or immediate element.

Parameters

stream	The stream to be written to.
elem	The element to be written.

Definition at line 200 of file TPEFCodeSectionWriter.cc.

                                {
 
    if (dynamic_cast<InstructionElement*>(elem)->isMove()) {
        MoveElement* move = dynamic_cast<MoveElement*>(elem);
 
        writeId(stream, move->bus());
 
        Byte fieldTypes = 0;
 
        if (!move->isEmpty()) {
 
            switch(move->sourceType()) {
            case MoveElement::MF_RF:
                fieldTypes |= TPEFHeaders::MVS_RF;
                break;
            case MoveElement::MF_IMM:
                fieldTypes |= TPEFHeaders::MVS_IMM;
                break;
            case MoveElement::MF_UNIT:
                fieldTypes |= TPEFHeaders::MVS_UNIT;
                break;
            default:
                std::cerr << "move source type: " << std::hex
                          << (int)move->sourceType() << std::dec << std::endl;
                assert(false);
            }
 
            switch(move->destinationType()) {
            case MoveElement::MF_RF:
                fieldTypes |= TPEFHeaders::MVD_RF;
                break;
            case MoveElement::MF_UNIT:
                fieldTypes |= TPEFHeaders::MVD_UNIT;
                break;
            default:
                std::cerr << "move dest type: "
                          << (int)move->destinationType()
                          << "\tdest unit: "
                          << (int)move->destinationUnit()
                          << "\tindex: "
                          << (int)move->destinationIndex()
                          << std::endl;
 
                assert(false);
            }
 
            if (move->isGuarded()) {
                switch(move->guardType()) {
                case MoveElement::MF_RF:
                    fieldTypes |= TPEFHeaders::MVG_RF;
                    break;
                case MoveElement::MF_UNIT:
                    fieldTypes |= TPEFHeaders::MVG_UNIT;
                    break;
                default:
                    std::cerr << "move guarde type: " << std::hex
                              << (int)move->guardType() 
                              << std::dec << std::endl;
                    assert(false);
                }
 
                if (move->isGuardInverted() != 0) {
                    fieldTypes |= TPEFHeaders::IE_GUARD_INV_MASK;
 
                }
            }
        }
 
        stream.writeByte(fieldTypes);
 
        writeId(stream, move->sourceUnit());
        stream.writeHalfWord(move->sourceIndex());
 
        writeId(stream, move->destinationUnit());
        stream.writeHalfWord(move->destinationIndex());
 
        writeId(stream, move->guardUnit());
        stream.writeHalfWord(move->guardIndex());
 
    } else {
        ImmediateElement* imm = dynamic_cast<ImmediateElement*>(elem);
        Byte dstUnit  = imm->destinationUnit();
        Byte dstIndex = imm->destinationIndex();
 
        stream.writeByte(dstUnit);
        stream.writeByte(dstIndex);
 
        assert(imm->length() <= IMMEDIATE_VALUE_MAX_BYTES);
 
        for (unsigned int i = 0; i < imm->length(); i++) {
            stream.writeByte(imm->byte(i));
        }
    }
}

References assert, TPEF::MoveElement::bus(), TPEF::ImmediateElement::byte(), TPEF::ImmediateElement::destinationIndex(), TPEF::MoveElement::destinationIndex(), TPEF::MoveElement::destinationType(), TPEF::ImmediateElement::destinationUnit(), TPEF::MoveElement::destinationUnit(), TPEF::MoveElement::guardIndex(), TPEF::MoveElement::guardType(), TPEF::MoveElement::guardUnit(), TPEF::TPEFHeaders::IE_GUARD_INV_MASK, IMMEDIATE_VALUE_MAX_BYTES, TPEF::MoveElement::isEmpty(), TPEF::MoveElement::isGuarded(), TPEF::MoveElement::isGuardInverted(), TPEF::ImmediateElement::length(), TPEF::MoveElement::MF_IMM, TPEF::MoveElement::MF_RF, TPEF::MoveElement::MF_UNIT, TPEF::TPEFHeaders::MVD_RF, TPEF::TPEFHeaders::MVD_UNIT, TPEF::TPEFHeaders::MVG_RF, TPEF::TPEFHeaders::MVG_UNIT, TPEF::TPEFHeaders::MVS_IMM, TPEF::TPEFHeaders::MVS_RF, TPEF::TPEFHeaders::MVS_UNIT, TPEF::MoveElement::sourceIndex(), TPEF::MoveElement::sourceType(), TPEF::MoveElement::sourceUnit(), TPEF::BinaryStream::writeByte(), TPEF::BinaryStream::writeHalfWord(), and writeId().

Referenced by actualWriteData().

Here is the call graph for this function:

writeId()

void TPEF::TPEFCodeSectionWriter::writeId ( BinaryStream &  stream, HalfWord  id  ) const

protectedvirtual

Writes Bus, FU or RF id according to TPEF version.

Original TPEF version 1 supports only less than 256 buses, FUs and RFs. Version 2 fixes that issue and we need to check the stream version for proper amount of bytes to write.

Parameters

stream	Stream to which the data is written.
sect	id of the component.

Definition at line 372 of file TPEFCodeSectionWriter.cc.

                                                                      {
 
    TPEFHeaders::TPEFVersion version = stream.TPEFVersion();
 
    if (version == TPEFHeaders::TPEFVersion::TPEF_V1) {
        stream.writeByte(id);
    } else {
        stream.writeHalfWord(id);
    }
}

References TPEF::TPEFHeaders::TPEF_V1, TPEF::BinaryStream::TPEFVersion(), TPEF::BinaryStream::writeByte(), and TPEF::BinaryStream::writeHalfWord().

Referenced by writeDataField().

Here is the call graph for this function:

writeInfo()

void TPEF::TPEFCodeSectionWriter::writeInfo ( BinaryStream &  stream, const Section *  sect  ) const

protectedvirtual

Writes the ‘info’ field of code section header.

The ‘info’ field of code sections normally contains information related to instruction size and encoding. The TUT_TTA architecture does not use this field and ignores its contents.

Parameters

stream	Stream to which the data is written.
sect	Input section. Unused.

Reimplemented from TPEF::TPEFSectionWriter.

Definition at line 351 of file TPEFCodeSectionWriter.cc.

                          {
 
    stream.writeHalfWord(0); // unused field
    stream.writeByte(0); // unused field - must be set to zero!
    stream.writeByte(0); // padding
}

References TPEF::BinaryStream::writeByte(), and TPEF::BinaryStream::writeHalfWord().

Here is the call graph for this function:

Member Data Documentation

IMMEDIATE_VALUE_MAX_BYTES

const Byte TPEF::TPEFCodeSectionWriter::IMMEDIATE_VALUE_MAX_BYTES = 16

staticprivate

Maximum number of bytes that single immediate can contain.

Definition at line 80 of file TPEFCodeSectionWriter.hh.

Referenced by writeDataField().

instance_

const TPEFCodeSectionWriter TPEF::TPEFCodeSectionWriter::instance_

staticprivate

Unique instance of class.

Definition at line 78 of file TPEFCodeSectionWriter.hh.

---

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

• TPEFCodeSectionWriter.hh
• TPEFCodeSectionWriter.cc