TPEF::TPEFSymbolSectionWriter Class Reference

#include <TPEFSymbolSectionWriter.hh>

Inheritance diagram for TPEF::TPEFSymbolSectionWriter:

Collaboration diagram for TPEF::TPEFSymbolSectionWriter:

Protected Member Functions
	TPEFSymbolSectionWriter ()
virtual	~TPEFSymbolSectionWriter ()
virtual Section::SectionType	type () const
virtual void	createKeys (const Section *sect) const
virtual void	actualWriteData (BinaryStream &stream, const Section *section) const
virtual Word	elementSize (const Section *section) 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	writeSize (BinaryStream &stream, const Section *sect) const
virtual void	writeInfo (BinaryStream &stream, const Section *sect) const
virtual SectionId	getSectionId () const
Protected Member Functions inherited from TPEF::SectionWriter
	SectionWriter ()
virtual	~SectionWriter ()
virtual void	finalize (BinaryStream &stream, Section *section) const

Private Member Functions
	TPEFSymbolSectionWriter (const TPEFSymbolSectionWriter &)
	Copying not allowed.
TPEFSymbolSectionWriter	operator= (const TPEFSymbolSectionWriter &)
	Assignment not allowed.
void	writeValueAndSize (BinaryStream &stream, const SymbolElement *elem) const

Static Private Attributes
static const TPEFSymbolSectionWriter	instance_
	An unique instance of class.
static const Word	elementSize_ = 16
	The fixed size address space element.

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 symbol table to stream.

Definition at line 47 of file TPEFSymbolSectionWriter.hh.

Constructor & Destructor Documentation

TPEFSymbolSectionWriter() [1/2]

TPEF::TPEFSymbolSectionWriter::TPEFSymbolSectionWriter ( )

protected

Constructor.

Registers itself to SectionWriter.

Definition at line 67 of file TPEFSymbolSectionWriter.cc.

                                                 : TPEFSectionWriter() {
    registerSectionWriter(this);
}

References TPEF::SectionWriter::registerSectionWriter().

Here is the call graph for this function:

~TPEFSymbolSectionWriter()

TPEF::TPEFSymbolSectionWriter::~TPEFSymbolSectionWriter ( )

protectedvirtual

Destructor.

Definition at line 74 of file TPEFSymbolSectionWriter.cc.

                                                  {
}

TPEFSymbolSectionWriter() [2/2]

TPEF::TPEFSymbolSectionWriter::TPEFSymbolSectionWriter ( const TPEFSymbolSectionWriter &  )

private

Copying not allowed.

Member Function Documentation

actualWriteData()

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

protectedvirtual

Writes the data of the section in to stream.

Parameters

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

Reimplemented from TPEF::TPEFSectionWriter.

Definition at line 94 of file TPEFSymbolSectionWriter.cc.

                               {
 
    FileOffset startOffset = stream.writePosition();
 
    // file offset to data of section
    SafePointer::addObjectReference(
        FileOffsetKey(startOffset), sect->element(0));
 
    // resolve identification code of currently written section
    SectionKey sectionKey = SafePointer::sectionKeyFor(sect);
    SectionId sectionId = sectionKey.sectionId();
 
    // first element should match with undefined symbol
    SymbolElement *undef = dynamic_cast<SymbolElement*>(sect->element(0));
    assert(undef != NULL);
    assert(undef->type() == SymbolElement::STT_NOTYPE);
    assert(undef->absolute() == true);
    assert(undef->binding() == SymbolElement::STB_LOCAL);
    assert(undef->name()->offset() == 0);
 
    // symbols might have to be organized in a way local symbols are
    // before weak symbols and global syms will come after everything else
    for (Word i = 0; i < sect->elementCount(); i++) {
 
        SymbolElement* elem = dynamic_cast<SymbolElement*>(sect->element(i));
        assert(elem != NULL);
 
        // each element must be registered with its index
        SafePointer::addObjectReference(
            SectionIndexKey(sectionId, i), elem);
 
        // write name
        assert(elem->name() != NULL);
        SectionOffsetReplacer sOffReplacer(elem->name());
        sOffReplacer.resolve();
 
        writeValueAndSize(stream, elem);
 
        // write info
        stream.writeByte(
            (elem->binding() << (BYTE_BITWIDTH / 2)) |
            static_cast<Byte>(elem->type()));
 
        // other field,  right now only STO_ABS is used
        Byte otherField = 0;
        if (elem->absolute()) {
            otherField = otherField | TPEFHeaders::STO_ABS;
        }
        stream.writeByte(otherField);
 
        // section to which the symbol belongs
        // NOTE: Maybe nullSection should be used for these,
        //       so NULL would be error.
 
        if (elem->section() != NULL) {
            SectionIdReplacer sectIdReplacer(elem->section());
            sectIdReplacer.resolve();
        } else {
            stream.writeHalfWord(0);
        }
    }
    SectionSizeReplacer::setSize(sect, stream.writePosition() - startOffset);
}

References TPEF::SymbolElement::absolute(), TPEF::ReferenceManager::SafePointer::addObjectReference(), assert, TPEF::SymbolElement::binding(), BYTE_BITWIDTH, TPEF::Section::element(), TPEF::Section::elementCount(), TPEF::SymbolElement::name(), TPEF::Chunk::offset(), TPEF::ValueReplacer::resolve(), TPEF::SymbolElement::section(), TPEF::ReferenceManager::SectionKey::sectionId(), TPEF::ReferenceManager::SafePointer::sectionKeyFor(), TPEF::SectionSizeReplacer::setSize(), TPEF::SymbolElement::STB_LOCAL, TPEF::TPEFHeaders::STO_ABS, TPEF::SymbolElement::STT_NOTYPE, TPEF::SymbolElement::type(), TPEF::BinaryStream::writeByte(), TPEF::BinaryStream::writeHalfWord(), TPEF::BinaryStream::writePosition(), and writeValueAndSize().

Here is the call graph for this function:

createKeys()

void TPEF::TPEFSymbolSectionWriter::createKeys ( const Section *  sect ) const

protectedvirtual

Creates needed keys for section if noBits flag is set.

Parameters

sect	Section which for keys will be created.

Reimplemented from TPEF::TPEFSectionWriter.

Definition at line 264 of file TPEFSymbolSectionWriter.cc.

                                                             {
    SectionSizeReplacer::setSize(sect, 0x0);
}

References TPEF::SectionSizeReplacer::setSize().

Here is the call graph for this function:

elementSize()

Word TPEF::TPEFSymbolSectionWriter::elementSize ( const Section *  section ) const

protectedvirtual

Returns the fixed size length of section elements.

Returns

The fixed size length of section elements.

Reimplemented from TPEF::TPEFSectionWriter.

Definition at line 254 of file TPEFSymbolSectionWriter.cc.

                                                           {
    return elementSize_;
}

References elementSize_.

operator=()

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

private

Assignment not allowed.

type()

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

protectedvirtual

Returns the section type this writer can write.

Returns

The section type writer can write.

Implements TPEF::TPEFSectionWriter.

Definition at line 83 of file TPEFSymbolSectionWriter.cc.

                                    {
    return Section::ST_SYMTAB;
}

References TPEF::Section::ST_SYMTAB.

writeValueAndSize()

void TPEF::TPEFSymbolSectionWriter::writeValueAndSize ( BinaryStream &  stream, const SymbolElement *  elem  ) const

private

Writes value and size fields of symbol.

Parameters

stream	Stream where to write.
elem	Element to write.

Definition at line 167 of file TPEFSymbolSectionWriter.cc.

                                     {
 
    switch (elem->type()) {
    case SymbolElement::STT_NOTYPE: {
        // write value
        // write size
        stream.writeWord(0);
        stream.writeWord(0);
        break;
    }
 
    case SymbolElement::STT_PROCEDURE:
    case SymbolElement::STT_CODE: {
        const CodeSymElement* codeSym =
            dynamic_cast<const CodeSymElement*>(elem);
        assert(codeSym != NULL);
 
        // write value
        if (codeSym->reference() != NULL) {
            SectionOffsetReplacer replacer(codeSym->reference());
            replacer.resolve();
        } else {
            stream.writeWord(0);
        }
 
        // write size
        stream.writeWord(codeSym->size());
        break;
    }
 
    case SymbolElement::STT_DATA: {
        const DataSymElement* dataSym =
            dynamic_cast<const DataSymElement*>(elem);
        assert(dataSym != NULL);
 
        // write value
        if (dataSym->reference() != NULL) {
            SectionOffsetReplacer replacer(dataSym->reference());
            replacer.resolve();
        } else {
            stream.writeWord(0);
        }
 
        // write size
        stream.writeWord(dataSym->size());
        break;
    }
 
    case SymbolElement::STT_SECTION: {
        const SectionSymElement* sectSym =
            dynamic_cast<const SectionSymElement*>(elem);
        assert(sectSym != NULL);
 
        // write value
        stream.writeWord(sectSym->value());
        // write size
        stream.writeWord(sectSym->size());
        break;
    }
 
    case SymbolElement::STT_FILE: {
        const FileSymElement* fileSym =
            dynamic_cast<const FileSymElement*>(elem);
        assert(fileSym != NULL);
 
        // write value
        stream.writeWord(fileSym->value());
        // write size
        stream.writeWord(0);
        break;
    }
 
    default: {
        bool unknownSymbolType = false;
        assert(unknownSymbolType);
    }
    }
}

References assert, TPEF::CodeSymElement::reference(), TPEF::DataSymElement::reference(), TPEF::ValueReplacer::resolve(), TPEF::CodeSymElement::size(), TPEF::DataSymElement::size(), TPEF::SectionSymElement::size(), TPEF::SymbolElement::STT_CODE, TPEF::SymbolElement::STT_DATA, TPEF::SymbolElement::STT_FILE, TPEF::SymbolElement::STT_NOTYPE, TPEF::SymbolElement::STT_PROCEDURE, TPEF::SymbolElement::STT_SECTION, TPEF::SymbolElement::type(), TPEF::FileSymElement::value(), TPEF::SectionSymElement::value(), and TPEF::BinaryStream::writeWord().

Referenced by actualWriteData().

Here is the call graph for this function:

Member Data Documentation

elementSize_

const Word TPEF::TPEFSymbolSectionWriter::elementSize_ = 16

staticprivate

The fixed size address space element.

Definition at line 75 of file TPEFSymbolSectionWriter.hh.

Referenced by elementSize().

instance_

const TPEFSymbolSectionWriter TPEF::TPEFSymbolSectionWriter::instance_

staticprivate

An unique instance of class.

Definition at line 73 of file TPEFSymbolSectionWriter.hh.

---

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

• TPEFSymbolSectionWriter.hh
• TPEFSymbolSectionWriter.cc