TPEF::TPEFReader Class Reference

#include <TPEFReader.hh>

Inheritance diagram for TPEF::TPEFReader:

Collaboration diagram for TPEF::TPEFReader:

Public Member Functions
Section *	sectionOfAddress (const ASpaceElement *aSpaceId, AddressImage address) const
SectionId	aSpaceId ()
SectionId	strTableId ()
void	addSectionSize (const Section *sect, Word length)
ASpaceSection *	aSpaceSection () const
Public Member Functions inherited from TPEF::BinaryReader
virtual	~BinaryReader ()

Static Public Member Functions
static BinaryReader *	instance ()
Static Public Member Functions inherited from TPEF::BinaryReader
static Binary *	readBinary (BinaryStream &stream)

Protected Member Functions
	TPEFReader (const TPEFReader &)
TPEFReader &	operator= (const TPEFReader &)
	TPEFReader ()
virtual	~TPEFReader ()
virtual Binary *	readData (BinaryStream &stream) const
virtual bool	isMyStreamType (BinaryStream &stream) const
Protected Member Functions inherited from TPEF::BinaryReader
	BinaryReader ()

Private Member Functions
Section *	readSection (BinaryStream &stream, FileOffset headerOffset, Byte stringTableId, Byte aSpaceSectionId) const

Private Attributes
Binary *	binary_
	Last or currently read binary.
SectionId	aSpaceId_
	Identification code of address space section (there is only one at maximum).
SectionId	strTableId_
	Identification code of string table containing section name strings.
std::map< const Section *, Word >	sectionSizes_
	Cache of sizes in addresses of read sections.

Static Private Attributes
static TPEFReader *	proto_ = NULL
	Prototype instance registered into BinaryReader.

Additional Inherited Members
Public Types inherited from TPEF::BinaryReader
typedef unsigned long	Length
Static Protected Member Functions inherited from TPEF::BinaryReader
static void	registerBinaryReader (BinaryReader *reader)

Detailed Description

Reads binary file that is in TPEF binary format.

Definition at line 52 of file TPEFReader.hh.

Constructor & Destructor Documentation

TPEFReader() [1/2]

TPEF::TPEFReader::TPEFReader ( const TPEFReader &  )

protected

TPEFReader() [2/2]

TPEF::TPEFReader::TPEFReader ( )

protected

Constructor.

Creates Header and registers itself to BinaryReader.

Definition at line 66 of file TPEFReader.cc.

                       : BinaryReader(), aSpaceId_(0), strTableId_(0) {
    BinaryReader::registerBinaryReader(this);
}

References TPEF::BinaryReader::registerBinaryReader().

Referenced by instance().

Here is the call graph for this function:

~TPEFReader()

TPEF::TPEFReader::~TPEFReader ( )

protectedvirtual

Destructor.

Definition at line 73 of file TPEFReader.cc.

                        {
    if (proto_ != NULL) {
        auto proto = proto_;
        proto_ = NULL;
        delete proto;
    }
}

References proto_.

Member Function Documentation

addSectionSize()

void TPEF::TPEFReader::addSectionSize	(	const Section *	sect,
		Word	length
	)

Stores size of a section as bytes.

Parameters

sect	Section whose size is stored.
length	Section data size in addresses.

Definition at line 320 of file TPEFReader.cc.

                                                           {
    sectionSizes_[sect] = length;
}

References sectionSizes_.

aSpaceId()

SectionId TPEF::TPEFReader::aSpaceId

(

)

Returns the identification code of the address space table section.

Returns

Identification code of the address space table section.

Definition at line 330 of file TPEFReader.cc.

                     {
    return aSpaceId_;
}

References aSpaceId_.

Referenced by TPEF::TPEFSectionReader::readData().

aSpaceSection()

ASpaceSection * TPEF::TPEFReader::aSpaceSection

(

)

const

Returns address space of file if already read.

Returns

Address space of binary. NULL if there is no ASpace.

Definition at line 351 of file TPEFReader.cc.

                                {
    for (unsigned int i = 0; i < binary_->sectionCount(); i++) {
        if (binary_->section(i)->type() == Section::ST_ADDRSP) {
            return dynamic_cast<ASpaceSection*>(binary_->section(i));
        }
    }
    return NULL;
}

References binary_, TPEF::Binary::section(), TPEF::Binary::sectionCount(), TPEF::Section::ST_ADDRSP, and TPEF::Section::type().

Referenced by TPEF::TPEFRelocSectionReader::finalize().

Here is the call graph for this function:

instance()

BinaryReader * TPEF::TPEFReader::instance ( )

static

Returns instance of reader.

Returns

Instance used for reading.

Definition at line 262 of file TPEFReader.cc.

                     {
    if (proto_ == NULL) {
        proto_ = new TPEFReader();
    }
    return proto_;
}

References proto_, and TPEFReader().

Referenced by TPEF::TPEFSectionReader::parent().

Here is the call graph for this function:

isMyStreamType()

bool TPEF::TPEFReader::isMyStreamType ( BinaryStream &  stream ) const

protectedvirtual

Checks if this reader is capable of reading the given stream.

This method does not modify the stream pointer.

Parameters

stream

The stream to test.

Returns

True if stream contains data in expected format, false otherwise.

Exceptions

UnreachableStream

If there occurs an exception with stream.

Implements TPEF::BinaryReader.

Definition at line 231 of file TPEFReader.cc.

                                                     {
    unsigned long startPos = stream.readPosition();
 
    try {
        if (stream.readByte() == 0x7f &&
            stream.readByte() == 'T' &&
            stream.readByte() == 'T' &&
            stream.readByte() == 'A' &&
            stream.readByte() == '-' &&
            stream.readByte() == 'P' &&
            stream.readByte() == 'F' &&
            stream.readByte() == 0x00) {
 
            stream.setReadPosition(startPos);
            return true;
        }
    } catch (EndOfFile& e) {
        stream.setReadPosition(startPos);
        return false;
    }
 
    stream.setReadPosition(startPos);
    return false;
}

References TPEF::BinaryStream::readByte(), TPEF::BinaryStream::readPosition(), and TPEF::BinaryStream::setReadPosition().

Here is the call graph for this function:

operator=()

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

protected

readData()

Binary * TPEF::TPEFReader::readData ( BinaryStream &  stream ) const

protectedvirtual

Does the actual work of reading binary file from stream.

Parameters

stream

Stream to be read from.

Returns

Pointer to the Binary object created.

Exceptions

UnreachableStream	If reading of section fails.
KeyAlreadyExists	Key was in use whent rying 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.

Implements TPEF::BinaryReader.

Definition at line 94 of file TPEFReader.cc.

                                               {
    binary_ = new Binary();
    sectionSizes_.clear();
 
    // let's read file header stuff
    FileOffset startOffset = stream.readPosition();
 
    // read file format identifier (including TPEF version number)
    stream.setReadPosition(startOffset + TPEFHeaders::FH_ID);
    for (Word i = 0; i < TPEFHeaders::FH_ID_SIZE; i++) {
        // TPEF version number is located in the 9th Byte of FH_ID header
        if (i == 8) {
            TPEFHeaders::TPEFVersion version =
                static_cast<TPEFHeaders::TPEFVersion>(stream.readByte());
            stream.setTPEFVersion(version);
            binary_->setTPEFVersion(version);
        } else {
            stream.readByte();
        }
    }
 
    stream.setReadPosition(startOffset + TPEFHeaders::FH_ARCH);
    binary_->setArch(
        static_cast<Binary::FileArchitecture>(stream.readByte()));
 
    stream.setReadPosition(startOffset + TPEFHeaders::FH_TYPE);
    binary_->setType(
        static_cast<Binary::FileType>(stream.readByte()));
 
    stream.setReadPosition(startOffset + TPEFHeaders::FH_SHOFF);
    FileOffset offsetToHeader = stream.readWord();
 
    // skip size of file header
 
    stream.setReadPosition(startOffset + TPEFHeaders::FH_SHSIZE);
    HalfWord sectionHeaderSize = stream.readHalfWord();
 
    stream.setReadPosition(startOffset + TPEFHeaders::FH_SHNUM);
    HalfWord sectionHeaderCount = stream.readHalfWord();
 
    // string table of section names
    stream.setReadPosition(startOffset + TPEFHeaders::FH_SHSTRTAB);
    Word stringTableFileOffset = stream.readWord();
 
    if (stringTableFileOffset != 0) {
        FileOffsetKey fKey(stringTableFileOffset);
        binary_->setStrings(CREATE_SAFEPOINTER(fKey));
    } else {
        binary_->setStrings(&SafePointer::null);
    }
 
    // get identification code of string table section of binary
    if (stringTableFileOffset != 0) {
        stream.setReadPosition(stringTableFileOffset + TPEFHeaders::SH_ID);
        SectionId stringTableSectionId = stream.readHalfWord();
        strTableId_ = stringTableSectionId;
    } else {
        strTableId_ = 0;
    }
 
    // get identification code of address space section of binary
    SectionId aSpaceSectionId = 0;
    bool programSectionWasFound = false;
    for (Word i = offsetToHeader;
         i < offsetToHeader + (sectionHeaderCount*sectionHeaderSize);
         i += sectionHeaderSize) {
 
        // go to start of section header
        stream.setReadPosition(i + TPEFHeaders::SH_TYPE);
 
        Section::SectionType sectionTypeToCheck =
            static_cast<Section::SectionType>(stream.readByte());
 
        // if section is ASpaceSection
        if (sectionTypeToCheck == Section::ST_ADDRSP) {
            bool brokenBinaryMoreThanOneASpaceSection =
                (aSpaceSectionId == 0);
            assert(brokenBinaryMoreThanOneASpaceSection);
 
            stream.setReadPosition(i + TPEFHeaders::SH_ID);
            aSpaceSectionId = stream.readHalfWord();
 
        } else if(Section::isProgramSection(sectionTypeToCheck)) {
            programSectionWasFound = true;
        }
    }
 
    // there must be address space
    assert(aSpaceSectionId != 0);
    aSpaceId_ = aSpaceSectionId;
 
    // let's do some serious section-reading...
    for (HalfWord i = 0; i < sectionHeaderCount; i++) {
 
        stream.setReadPosition(offsetToHeader + TPEFHeaders::SH_TYPE);
 
        Section* sect = Section::createSection(
            static_cast<Section::SectionType>(stream.readByte()));
 
        FileOffsetKey sectionFileOffsetKey(offsetToHeader);
        SafePointer::addObjectReference(sectionFileOffsetKey, sect);
 
        stream.setReadPosition(offsetToHeader);
 
        SectionReader::readSection(stream, sect, proto_);
 
        // next header
        offsetToHeader += sectionHeaderSize;
        binary_->addSection(sect);
    }
 
    // NOTE: This check might be better to do in Binary classes addSection
    //       method. Because it's Binary classes job to prevent illegal
    //       section set. This check only prevents adding too many of these
    //       section while reading.
 
    // make sure that binary has needed sctions and do not have too many
    // resource or address space sections
    assert(binary_->sectionCount(Section::ST_ADDRSP) == 1);
    assert(binary_->sectionCount(Section::ST_NULL) == 1);
    assert((binary_->sectionCount(Section::ST_MR) == 1) ||
           (binary_->sectionCount(Section::ST_MR) == 0 &&
            programSectionWasFound == false));
 
    return binary_;
}

References TPEF::ReferenceManager::SafePointer::addObjectReference(), TPEF::Binary::addSection(), aSpaceId_, assert, binary_, TPEF::Section::createSection(), TPEF::TPEFHeaders::FH_ARCH, TPEF::TPEFHeaders::FH_ID, TPEF::TPEFHeaders::FH_ID_SIZE, TPEF::TPEFHeaders::FH_SHNUM, TPEF::TPEFHeaders::FH_SHOFF, TPEF::TPEFHeaders::FH_SHSIZE, TPEF::TPEFHeaders::FH_SHSTRTAB, TPEF::TPEFHeaders::FH_TYPE, TPEF::Section::isProgramSection(), TPEF::ReferenceManager::SafePointer::null, proto_, TPEF::BinaryStream::readByte(), TPEF::BinaryStream::readHalfWord(), TPEF::BinaryStream::readPosition(), TPEF::SectionReader::readSection(), TPEF::BinaryStream::readWord(), TPEF::Binary::sectionCount(), sectionSizes_, TPEF::Binary::setArch(), TPEF::BinaryStream::setReadPosition(), TPEF::Binary::setStrings(), TPEF::Binary::setTPEFVersion(), TPEF::BinaryStream::setTPEFVersion(), TPEF::Binary::setType(), TPEF::TPEFHeaders::SH_ID, TPEF::TPEFHeaders::SH_TYPE, TPEF::Section::ST_ADDRSP, TPEF::Section::ST_MR, TPEF::Section::ST_NULL, and strTableId_.

Here is the call graph for this function:

readSection()

Section * TPEF::TPEFReader::readSection ( BinaryStream &  stream, FileOffset  headerOffset, Byte  stringTableId, Byte  aSpaceSectionId  ) const

private

sectionOfAddress()

Section * TPEF::TPEFReader::sectionOfAddress	(	const ASpaceElement *	aSpace,
		AddressImage	address
	)		const

Resolves, which section is in given address in last read binary file.

Parameters

aSpace	Address space in which section resides in memory image.
address	Address whose section is resolved.

Returns

Section to which given offset refers.

Definition at line 277 of file TPEFReader.cc.

                                {
    
    assert(binary_ != NULL);
    
    for (Word i = 0; i < binary_->sectionCount(); i++) {
 
        Section *sect = binary_->section(i);
 
        // if section have same aSpace that in parameter
        if (sect->aSpace() == aSpace) {
 
            Word lastSectionAddress = sect->startingAddress();
 
            if (sect->isCodeSection()) {
                lastSectionAddress += 
                    dynamic_cast<CodeSection*>(sect)->instructionCount();
                
            } else {
                lastSectionAddress += 
                    dynamic_cast<RawSection*>(sect)->lengthInMAUs();
            }
 
            // test if address is inside base + sh_size
            if (address < lastSectionAddress &&
                address >= sect->startingAddress()) {
 
                return sect;
            }
        }
    }
 
    return NULL;
}

References TPEF::Section::aSpace(), assert, binary_, TPEF::Section::isCodeSection(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), and TPEF::Section::startingAddress().

Referenced by TPEF::TPEFRelocSectionReader::finalize().

Here is the call graph for this function:

strTableId()

SectionId TPEF::TPEFReader::strTableId

(

)

Returns the identification code of string table section that contains the names of the sections.

Returns

Identification code of a string table section.

Definition at line 341 of file TPEFReader.cc.

                       {
    return strTableId_;
}

References strTableId_.

Referenced by TPEF::TPEFSectionReader::readData().

Member Data Documentation

aSpaceId_

SectionId TPEF::TPEFReader::aSpaceId_

mutableprivate

Identification code of address space section (there is only one at maximum).

Definition at line 93 of file TPEFReader.hh.

Referenced by aSpaceId(), and readData().

binary_

Binary* TPEF::TPEFReader::binary_

mutableprivate

Last or currently read binary.

Definition at line 90 of file TPEFReader.hh.

Referenced by aSpaceSection(), readData(), and sectionOfAddress().

proto_

TPEFReader * TPEF::TPEFReader::proto_ = NULL

staticprivate

Prototype instance registered into BinaryReader.

Definition at line 87 of file TPEFReader.hh.

Referenced by instance(), readData(), and ~TPEFReader().

sectionSizes_

std::map<const Section*, Word> TPEF::TPEFReader::sectionSizes_

mutableprivate

Cache of sizes in addresses of read sections.

Definition at line 97 of file TPEFReader.hh.

Referenced by addSectionSize(), and readData().

strTableId_

SectionId TPEF::TPEFReader::strTableId_

mutableprivate

Identification code of string table containing section name strings.

Definition at line 95 of file TPEFReader.hh.

Referenced by readData(), and strTableId().

---

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

• TPEFReader.hh
• TPEFReader.cc