TPEF::TPEFCodeSectionReader Class Reference

#include <TPEFCodeSectionReader.hh>

Inheritance diagram for TPEF::TPEFCodeSectionReader:

Collaboration diagram for TPEF::TPEFCodeSectionReader:

Protected Member Functions
	TPEFCodeSectionReader ()
virtual	~TPEFCodeSectionReader ()
virtual void	readData (BinaryStream &stream, Section *section) const
virtual Section::SectionType	type () const
virtual void	readInfo (BinaryStream &stream, Section *sect) const
virtual HalfWord	readId (BinaryStream &stream) const
Protected Member Functions inherited from TPEF::TPEFSectionReader
	TPEFSectionReader ()
virtual BinaryReader *	parent () const
Protected Member Functions inherited from TPEF::SectionReader
	SectionReader ()
virtual void	finalize (Section *section) const

Private Member Functions
	TPEFCodeSectionReader (const TPEFCodeSectionReader &)
	Copying not allowed.
TPEFCodeSectionReader &	operator= (TPEFCodeSectionReader &)
	Assignment not allowed.
void	readAnnotations (BinaryStream &stream, InstructionElement *elem) const

Static Private Attributes
static TPEFCodeSectionReader	proto_
	Prototype instance of TPEFCodeSectionReader to be registered to SectionReader.

Additional Inherited Members
Public Types inherited from TPEF::SectionReader
typedef BinaryReader::Length	Length
Public Member Functions inherited from TPEF::TPEFSectionReader
virtual	~TPEFSectionReader ()
Public Member Functions inherited from TPEF::SectionReader
virtual	~SectionReader ()
Static Public Member Functions inherited from TPEF::SectionReader
static void	readSection (BinaryStream &stream, Section *section, BinaryReader *reader)
static void	finalizeBinary (Binary *binaryToFinalize, BinaryReader *reader)
Static Protected Member Functions inherited from TPEF::TPEFSectionReader
static const Header &	header ()
Static Protected Member Functions inherited from TPEF::SectionReader
static const SectionReader *	findSectionReader (const Section::SectionType type, const BinaryReader *bReader)
static void	registerSectionReader (const SectionReader *sReader)

Detailed Description

Reads code section from TPEF binary file.

Definition at line 47 of file TPEFCodeSectionReader.hh.

Constructor & Destructor Documentation

TPEFCodeSectionReader() [1/2]

TPEF::TPEFCodeSectionReader::TPEFCodeSectionReader ( )

protected

Constructor.

Registers itself to SectionReader.

Definition at line 60 of file TPEFCodeSectionReader.cc.

                                             : TPEFSectionReader() {
    SectionReader::registerSectionReader(this);
}

References TPEF::SectionReader::registerSectionReader().

Here is the call graph for this function:

~TPEFCodeSectionReader()

TPEF::TPEFCodeSectionReader::~TPEFCodeSectionReader ( )

protectedvirtual

Destructor.

Definition at line 67 of file TPEFCodeSectionReader.cc.

                                              {
}

TPEFCodeSectionReader() [2/2]

TPEF::TPEFCodeSectionReader::TPEFCodeSectionReader ( const TPEFCodeSectionReader &  )

private

Copying not allowed.

Member Function Documentation

operator=()

TPEFCodeSectionReader & TPEF::TPEFCodeSectionReader::operator= ( TPEFCodeSectionReader &  )

private

Assignment not allowed.

readAnnotations()

void TPEF::TPEFCodeSectionReader::readAnnotations ( BinaryStream &  stream, InstructionElement *  elem  ) const

private

Reads annotation fields and adds them to instruction.

TODO: move to inline file...

Parameters

stream	Stream pointing to start of annotation.
elem	Instruction where read annotations are added.

Definition at line 285 of file TPEFCodeSectionReader.cc.

                                                                       {
    bool continuation = true;
 
    while (continuation) {
        Byte sizeAndContinuation = stream.readByte();
 
        // if continuation bit is down
        if ((sizeAndContinuation & TPEFHeaders::IANNOTE_CONTINUATION) == 0) {
            continuation = false;
        }
 
 
        Byte payloadSize = sizeAndContinuation & TPEFHeaders::IANNOTE_SIZE;
 
        // read three byte wide value (from big endian format)
        Word id = stream.readByte() |
            (static_cast<Word>(stream.readByte()) << (BYTE_BITWIDTH))|
            (static_cast<Word>(stream.readByte()) << (BYTE_BITWIDTH*2));
 
        InstructionAnnotation *newAnnotation =
            new InstructionAnnotation(id);
 
        for (int i = 0; i < payloadSize; i++) {
            newAnnotation->addByte(stream.readByte());
        }
 
        elem->addAnnotation(newAnnotation);
    }
}

References TPEF::InstructionElement::addAnnotation(), TPEF::InstructionAnnotation::addByte(), BYTE_BITWIDTH, TPEF::TPEFHeaders::IANNOTE_CONTINUATION, TPEF::TPEFHeaders::IANNOTE_SIZE, and TPEF::BinaryStream::readByte().

Referenced by readData().

Here is the call graph for this function:

readData()

void TPEF::TPEFCodeSectionReader::readData ( BinaryStream &  stream, Section *  section  ) const

protectedvirtual

Reads section data from TPEF binary file.

Parameters

stream	Stream to be read from.
section	Section where the information is to be stored.

Exceptions

UnreachableStream	If reading of section fails.
KeyAlreadyExists	Key was in use when trying to register object.
EndOfFile	If end of file were reached while it shouldn't.
OutOfRange	Some of read values were out of range.
WrongSubclass	Some class couldn't do what it was asked for.
UnexpectedValue	If there was unexpected value when reading.

Reimplemented from TPEF::TPEFSectionReader.

Definition at line 93 of file TPEFCodeSectionReader.cc.

                                                                            {
    // base classes implementation must be called with these.
    TPEFSectionReader::readData(stream, section);
 
    CodeSection* codeSection = dynamic_cast<CodeSection*>(section);
    assert(codeSection != NULL);
 
    bool nextIsBeginning = true;
    Word sectionIndex = 0;
 
    // check that link section is defined properly
    // (should point to machine resource section)
    assert(header().linkId != 0);
 
    if (!section->noBits()) {
 
        while (stream.readPosition() <
               header().bodyLength + header().bodyOffset) {
 
            SectionOffsetKey
                sOffsetKey(header().sectionId,
                           stream.readPosition() - header().bodyOffset);
 
            Byte iAttr = stream.readByte();
 
            InstructionElement* newInstrElement = NULL;
 
            //if instruction is immediate
            if (iAttr & TPEFHeaders::IA_TYPE) {
 
                ImmediateElement* newElem = new ImmediateElement();
                newInstrElement = dynamic_cast<InstructionElement*>(newElem);
 
                newElem->setDestinationUnit(stream.readByte());
                newElem->setDestinationIndex(stream.readByte());
 
                //iAttr mask 0xF0 number of bytes of immediate
                Byte size = (iAttr >> (BYTE_BITWIDTH / 2));
 
                for (Byte i = 0; i < size; i++) {
                    newElem->addByte(stream.readByte());
                }
 
            } else {
 
                MoveElement* newElem = new MoveElement();
                newInstrElement = dynamic_cast<InstructionElement*>(newElem);
 
                newElem->setBus(readId(stream));
 
                Byte fieldTypes = stream.readByte();
 
                if (iAttr & TPEFHeaders::IA_EMPTY) {
                    newElem->setEmpty(true);
 
                } else {
                    newElem->setEmpty(false);
 
                    switch (fieldTypes & TPEFHeaders::IE_SRC_TYPE_MASK) {
                    case TPEFHeaders::MVS_RF:
                        newElem->setSourceType(MoveElement::MF_RF);
                        break;
                    case TPEFHeaders::MVS_IMM:
                        newElem->setSourceType(MoveElement::MF_IMM);
                        break;
                    case TPEFHeaders::MVS_UNIT:
                        newElem->setSourceType(MoveElement::MF_UNIT);
                        break;
                    default:
                        std::cerr << "field types: " 
                                  << std::hex << (int)fieldTypes
                                  << std::dec << std::endl;
                        assert(false);
                    }
 
                    switch (fieldTypes & TPEFHeaders::IE_DST_TYPE_MASK) {
                    case TPEFHeaders::MVD_RF:
                        newElem->setDestinationType(MoveElement::MF_RF);
                        break;
                    case TPEFHeaders::MVD_UNIT:
                        newElem->setDestinationType(MoveElement::MF_UNIT);
                        break;
                    default:
                        std::cerr << "field types: " 
                                  << std::hex << (int)fieldTypes
                                  << std::dec << std::endl;
                        assert(false);
                    }
 
 
                    if (iAttr & TPEFHeaders::IA_MGUARD) {
                        newElem->setGuarded(true);
 
                        switch (fieldTypes & 
                                TPEFHeaders::IE_GUARD_TYPE_MASK) {
 
                        case TPEFHeaders::MVG_UNIT:
                            newElem->setGuardType(MoveElement::MF_UNIT);
                            break;
                        case TPEFHeaders::MVG_RF:
                            newElem->setGuardType(MoveElement::MF_RF);
                            break;
                        default:
                            std::cerr << "field types: " << std::hex
                                      << (int)fieldTypes 
                                      << std::dec << std::endl;
                            assert(false);
                        }
 
                    } else {
                        newElem->setGuarded(false);
                    }
                }
 
                newElem->setSourceUnit(readId(stream));
                newElem->setSourceIndex(stream.readHalfWord());
 
                newElem->setDestinationUnit(readId(stream));
                newElem->setDestinationIndex(stream.readHalfWord());
 
                newElem->setGuardUnit(readId(stream));
                newElem->setGuardIndex(stream.readHalfWord());
 
                // guard extra parameters
                if (fieldTypes & TPEFHeaders::IE_GUARD_INV_MASK) {
                    newElem->setGuardInverted(true);
                } else {
                    newElem->setGuardInverted(false);
                }
            }
 
            newInstrElement->setBegin(nextIsBeginning);
            nextIsBeginning = (iAttr & TPEFHeaders::IA_END);
 
            // create annotations for instruction if there are any
            if (iAttr & TPEFHeaders::IA_ANNOTE) {
                readAnnotations(stream, newInstrElement);
            }
 
            // store reference to number of instruction for
            // relocation destination resolving
            if (newInstrElement->begin()) {
                SectionIndexKey
                    sIndexKey(header().sectionId, sectionIndex);
                SafePointer::addObjectReference(sIndexKey, newInstrElement);
                sectionIndex++;
            }
 
            SafePointer::addObjectReference(sOffsetKey, newInstrElement);
            codeSection->addElement(newInstrElement);
        }
 
        // add section size to parent
        dynamic_cast<TPEFReader*>(
            parent())->addSectionSize(section, sectionIndex);
    }
}

References TPEF::ImmediateElement::addByte(), TPEF::CodeSection::addElement(), TPEF::ReferenceManager::SafePointer::addObjectReference(), assert, TPEF::InstructionElement::begin(), BYTE_BITWIDTH, TPEF::TPEFSectionReader::header(), TPEF::TPEFHeaders::IA_ANNOTE, TPEF::TPEFHeaders::IA_EMPTY, TPEF::TPEFHeaders::IA_END, TPEF::TPEFHeaders::IA_MGUARD, TPEF::TPEFHeaders::IA_TYPE, TPEF::TPEFHeaders::IE_DST_TYPE_MASK, TPEF::TPEFHeaders::IE_GUARD_INV_MASK, TPEF::TPEFHeaders::IE_GUARD_TYPE_MASK, TPEF::TPEFHeaders::IE_SRC_TYPE_MASK, 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::Section::noBits(), TPEF::TPEFSectionReader::parent(), readAnnotations(), TPEF::BinaryStream::readByte(), TPEF::TPEFSectionReader::readData(), TPEF::BinaryStream::readHalfWord(), readId(), TPEF::BinaryStream::readPosition(), 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::MoveElement::setSourceIndex(), TPEF::MoveElement::setSourceType(), and TPEF::MoveElement::setSourceUnit().

Here is the call graph for this function:

readId()

HalfWord TPEF::TPEFCodeSectionReader::readId ( BinaryStream &  stream ) const

protectedvirtual

Reads 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 read.

Parameters

stream

Stream to which the data is read.

Definition at line 326 of file TPEFCodeSectionReader.cc.

                                                        {
 
    TPEFHeaders::TPEFVersion version = stream.TPEFVersion();
 
    if (version == TPEFHeaders::TPEF_V1) {
        return stream.readByte();
    } else {
        return stream.readHalfWord();
    }
}

References TPEF::BinaryStream::readByte(), TPEF::BinaryStream::readHalfWord(), TPEF::TPEFHeaders::TPEF_V1, and TPEF::BinaryStream::TPEFVersion().

Referenced by readData().

Here is the call graph for this function:

readInfo()

void TPEF::TPEFCodeSectionReader::readInfo ( BinaryStream &  stream, Section *  sect  ) const

protectedvirtual

Reads the info field of code section header.

The ‘info’ field of code sections normally contains the size of instruction word in memory image (in MAUs) and the instruction encoding type identifier. This information is ignored by the TUT_TTA architecture. The read position of the stream is moved 4 bytes forward.

Todo:

Convert assertion onnstruction encoder identifier into a test with warning or error message.

Parameters

stream	Stream from which the field is read.
sect	Target section. Unused.

Reimplemented from TPEF::TPEFSectionReader.

Definition at line 266 of file TPEFCodeSectionReader.cc.

                    {
 
    stream.readHalfWord(); // ignored
    assert(stream.readByte() == 0); // instruction encoding ID
    stream.readByte(); // padding - should warn if nonzero
}

References assert, TPEF::BinaryStream::readByte(), and TPEF::BinaryStream::readHalfWord().

Here is the call graph for this function:

type()

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

protectedvirtual

Returns the type of section it is meant to read.

Returns

The type of section it can read.

Implements TPEF::SectionReader.

Definition at line 76 of file TPEFCodeSectionReader.cc.

                                  {
    return Section::ST_CODE;
}

References TPEF::Section::ST_CODE.

Member Data Documentation

proto_

TPEFCodeSectionReader TPEF::TPEFCodeSectionReader::proto_

staticprivate

Prototype instance of TPEFCodeSectionReader to be registered to SectionReader.

Definition at line 70 of file TPEFCodeSectionReader.hh.

---

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

• TPEFCodeSectionReader.hh
• TPEFCodeSectionReader.cc