TPEF::AOutRelocationSectionReader Class Reference

#include <AOutRelocationSectionReader.hh>

Inheritance diagram for TPEF::AOutRelocationSectionReader:

Collaboration diagram for TPEF::AOutRelocationSectionReader:

Public Member Functions
virtual	~AOutRelocationSectionReader ()
Public Member Functions inherited from TPEF::AOutSectionReader
virtual	~AOutSectionReader ()
Public Member Functions inherited from TPEF::SectionReader
virtual	~SectionReader ()

Protected Member Functions
	AOutRelocationSectionReader ()
virtual void	finalize (Section *section) const
virtual void	readData (BinaryStream &stream, Section *section) const
virtual Section::SectionType	type () const
Protected Member Functions inherited from TPEF::AOutSectionReader
	AOutSectionReader ()
virtual BinaryReader *	parent () const
Protected Member Functions inherited from TPEF::SectionReader
	SectionReader ()

Private Types
enum	RelocType { RELOC_8, RELOC_16, RELOC_32, NO_RELOC }

Private Member Functions
void	initializeRelocElement (BinaryStream &stream, RelocElement *elem, SectionId refSectionID, AOutReader *reader) const
bool	checkIfExtern (Word word) const
	AOutRelocationSectionReader (const AOutRelocationSectionReader &)
	Copying not allowed. More...
AOutRelocationSectionReader &	operator= (AOutRelocationSectionReader &)
	Assignment not allowed. More...
RelocElement::RelocType	aOutToTPEFRelocType (RelocType aOutRelocType) const

Static Private Attributes
static AOutRelocationSectionReader	proto_
	Class-wide (unique) prototype instance of AOutRelocationSectionReader registered into SectionReader. More...
static const Byte	RELOCATION_TYPE_MASK = 0x1F
	Mask for extracting relocation type. More...

Additional Inherited Members
Public Types inherited from TPEF::SectionReader
typedef BinaryReader::Length	Length
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::SectionReader
static const SectionReader *	findSectionReader (const Section::SectionType type, const BinaryReader *bReader)
static void	registerSectionReader (const SectionReader *sReader)

Detailed Description

Reads relocation sections of a.out binary.

Definition at line 51 of file AOutRelocationSectionReader.hh.

Member Enumeration Documentation

RelocType

enum TPEF::AOutRelocationSectionReader::RelocType

private

Relocation types of a.out

Enumerator
RELOC_8	1 byte relocation
RELOC_16	2 bytes relocation
RELOC_32	4 bytes relocation
NO_RELOC	no relocation

Definition at line 68 of file AOutRelocationSectionReader.hh.

                   {
        RELOC_8,   ///< 1 byte relocation 
        RELOC_16,  ///< 2 bytes relocation 
        RELOC_32,  ///< 4 bytes relocation
        NO_RELOC   ///< no relocation
    };

Constructor & Destructor Documentation

~AOutRelocationSectionReader()

TPEF::AOutRelocationSectionReader::~AOutRelocationSectionReader ( )

virtual

Destructor.

Definition at line 76 of file AOutRelocationSectionReader.cc.

                                                          {
}

AOutRelocationSectionReader() [1/2]

TPEF::AOutRelocationSectionReader::AOutRelocationSectionReader ( )

protected

Constructor.

Registers itself to AOutSectionReader.

Definition at line 67 of file AOutRelocationSectionReader.cc.

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

References TPEF::SectionReader::registerSectionReader().

Here is the call graph for this function:

AOutRelocationSectionReader() [2/2]

TPEF::AOutRelocationSectionReader::AOutRelocationSectionReader ( const AOutRelocationSectionReader &  )

private

Copying not allowed.

Member Function Documentation

aOutToTPEFRelocType()

RelocElement::RelocType TPEF::AOutRelocationSectionReader::aOutToTPEFRelocType ( RelocType  aOutRelocType ) const

private

Converts a.out relocation type into TPEF relocation.

Parameters

aOutRelocType

Identification code of the relocation type to convert to TPEF format.

Returns

TPEF relocation type.

Definition at line 295 of file AOutRelocationSectionReader.cc.

                                   {
 
    // NOTE: check this conversion.
 
    switch (aOutRelocType) {
    case RELOC_8:
    case RELOC_16:
    case RELOC_32:
        return RelocElement::RT_SELF;
    case NO_RELOC:
        return RelocElement::RT_NOREL;
    default: {
        bool unknownAOutRelocationType = false;
        assert(unknownAOutRelocationType);
    }
    }
 
    // to prevent compile warnings
    return RelocElement::RT_NOREL;
}

References assert, NO_RELOC, RELOC_16, RELOC_32, RELOC_8, TPEF::RelocElement::RT_NOREL, and TPEF::RelocElement::RT_SELF.

Referenced by initializeRelocElement().

checkIfExtern()

bool TPEF::AOutRelocationSectionReader::checkIfExtern ( Word  word ) const

private

Referenced by initializeRelocElement().

finalize()

void TPEF::AOutRelocationSectionReader::finalize ( Section *  section ) const

protectedvirtual

Finalizer method for AOut relocation sections.

Fixes values of elements pointed by location(), MOVE linker does not update values of elements referred from relocation. Also sets address spaces for relocation elements.

Parameters

section

Section to finalize.

Reimplemented from TPEF::SectionReader.

Definition at line 224 of file AOutRelocationSectionReader.cc.

                                                            {
 
    Section *refSection =
        dynamic_cast<RelocSection*>(section)->referencedSection();
 
    AOutReader *aOutReader = dynamic_cast<AOutReader*>(parent());
    assert(aOutReader != NULL);
 
    for (Word i = 0;
         i != section->elementCount();
         i++) {
 
        RelocElement *elem = dynamic_cast<RelocElement*>(section->element(i));
 
        // address space of section where element is or undef aSpace
        elem->setASpace(
            dynamic_cast<AOutReader*>
            (parent())->aSpaceOfElement(elem->destination()));
 
        // relocation is unresolved.
        if (elem->destination() == NULL) continue;
 
        AddressImage destAddress =
            aOutReader->addressOfElement(elem->destination());
 
        // fix value of immediate or chunk
        if (refSection->isCodeSection()) {
 
            // value of immediate element, is file offset to
            // that element, which to immediate refers
            ImmediateElement *imm =
                dynamic_cast<ImmediateElement*>(elem->location());
 
            // relocation must have Immediate or Chunk element as location
            assert(imm != NULL);
 
            // fix the address value
            imm->setWord(destAddress);
 
        } else if (refSection->type() == Section::ST_DATA) {
            Chunk* dataChunk = dynamic_cast<Chunk*>(elem->location());
            DataSection* dataSection = dynamic_cast<DataSection*>(refSection);
 
            // check that section is long enough
            if (dataChunk->offset() + sizeof(destAddress) >
                dataSection->length()) {
                bool requestedChunkWasOutOfRange = false;
                assert(requestedChunkWasOutOfRange);
            }
 
            // fix address of chunk
            Word mauIndex = dataSection->chunkToMAUIndex(dataChunk);
 
            dataSection->writeValue(
                mauIndex, 4, static_cast<unsigned long>(destAddress));
 
        } else {
            bool referencedSectionMustBeEitherCodeOrData = false;
            assert(referencedSectionMustBeEitherCodeOrData);
        }
    }
}

References TPEF::AOutReader::addressOfElement(), TPEF::AOutReader::aSpaceOfElement(), assert, TPEF::RawSection::chunkToMAUIndex(), TPEF::RelocElement::destination(), TPEF::Section::element(), TPEF::Section::elementCount(), TPEF::Section::isCodeSection(), TPEF::DataSection::length(), TPEF::RelocElement::location(), TPEF::Chunk::offset(), TPEF::AOutSectionReader::parent(), TPEF::RelocElement::setASpace(), TPEF::ImmediateElement::setWord(), TPEF::Section::ST_DATA, TPEF::Section::type(), and TPEF::DataSection::writeValue().

Here is the call graph for this function:

initializeRelocElement()

void TPEF::AOutRelocationSectionReader::initializeRelocElement ( BinaryStream &  stream, RelocElement *  elem, SectionId  refSectionID, AOutReader *  reader  ) const

private

Initializes one RelocElement object with correct values.

Parameters

stream	The stream to be read from.
elem	Element to be initialized.
refSectionID	Identification code of the section that holds relocation source.
reader	The base reader for a.out.

Exceptions

UnexpectedValue	If extern bit is not zero, or if relocation target is not text or data section.
UnreachableStream	If stream can't be read.
OutOfRange	Section offset of an address is invalid.

Definition at line 158 of file AOutRelocationSectionReader.cc.

                              {
    Word r_address = stream.readWord();
 
    // if referenced section is text section fix r_address to point
    // starting element of instruction
    // (r_address pointed in the middle of move to immediate value before)
    if (refSectionID == AOutReader::ST_TEXT) {
        r_address -= AOutTextSectionReader::OFFSET_TO_IMMEDIATE_VALUE;
    }
 
    SectionOffsetKey sKey = SectionOffsetKey(refSectionID, r_address);
    elem->setLocation(CREATE_SAFEPOINTER(sKey));
 
    Word secondWord = stream.readWord();
 
    Word r_symbolnum = (secondWord >> BYTE_BITWIDTH);
 
    // addend is value that is stored in element in location pointed by
    // r_address
    AddressImage r_addend = stream.readWord();
 
    // It seems that extern flag and addend field is used to tell does
    // relocation have symbol or section index in symbolnum field.
    // If there is symbol it means that relocation is unresolved.
 
    // NOTE: above doesn't work if there is relocation to the 
    //       first instruction of program in this case secondWord seems to
    //       be always 1026... 
    if (r_addend == 0 &&  checkIfExtern(secondWord) && secondWord != 1026) {
        SectionIndexKey indexKey(AOutReader::ST_SYMBOL, r_symbolnum + 1);
        elem->setSymbol(CREATE_SAFEPOINTER(indexKey));
 
    } else {
        // if we are here r_symbolnum is a section id, not a symbol index
        SectionIndexKey undefSym(AOutReader::ST_SYMBOL,0);
        elem->setSymbol(CREATE_SAFEPOINTER(undefSym));
 
        Word r_offset = reader->sectionOffsetOfAddress(r_addend);
 
        SectionOffsetKey offKey =
            SectionOffsetKey(r_symbolnum, r_offset);
            
        elem->setDestination(CREATE_SAFEPOINTER(offKey));
    }
 
    // convert and set relocation type
    RelocType r_type =
        static_cast<RelocType>(secondWord & RELOCATION_TYPE_MASK);
 
    elem->setType(aOutToTPEFRelocType(r_type));
 
    elem->setSize(sizeof(Word)*BYTE_BITWIDTH);
}

References aOutToTPEFRelocType(), BYTE_BITWIDTH, checkIfExtern(), TPEF::AOutTextSectionReader::OFFSET_TO_IMMEDIATE_VALUE, TPEF::BinaryStream::readWord(), RELOCATION_TYPE_MASK, TPEF::AOutReader::sectionOffsetOfAddress(), TPEF::RelocElement::setDestination(), TPEF::RelocElement::setLocation(), TPEF::RelocElement::setSize(), TPEF::RelocElement::setSymbol(), TPEF::RelocElement::setType(), TPEF::AOutReader::ST_SYMBOL, and TPEF::AOutReader::ST_TEXT.

Referenced by readData().

Here is the call graph for this function:

operator=()

AOutRelocationSectionReader& TPEF::AOutRelocationSectionReader::operator= ( AOutRelocationSectionReader &  )

private

Assignment not allowed.

readData()

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

protectedvirtual

Reads relocation sections from a.out binary file.

Parameters

stream	The stream to be read from.
section	Section where to information is 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.

Implements TPEF::SectionReader.

Definition at line 102 of file AOutRelocationSectionReader.cc.

                                                  {
    FileOffset offset = stream.readPosition();
 
    AOutReader* aOutReader = dynamic_cast<AOutReader*>(parent());
    assert(aOutReader != NULL);
 
    // find out whether this is for reading text relocation or data
    // relocation
    RelocSection* relocSection = dynamic_cast<RelocSection*>(section);
    assert(relocSection != NULL);
 
    const Section* refSection = relocSection->referencedSection();
    assert(refSection != NULL);
 
    SectionId refSectionID;
 
    Word length = 0;
    if (refSection->isCodeSection()) {
        refSectionID = AOutReader::ST_TEXT;
        length = aOutReader->header().sectionSizeTextReloc();
 
    } else if (refSection->type() == Section::ST_DATA) {
        refSectionID = AOutReader::ST_DATA;
        length = aOutReader->header().sectionSizeDataReloc();
 
    } else {
        string msg = "Relocating something else than text or data section";
        throw WrongSubclass(__FILE__, __LINE__, __func__, msg);
    }
 
    // all relocation information is read; to offset 'offset+length'
    for (; stream.readPosition() < offset + length;) {
 
        // create and read a new relocation element
        RelocElement* elem = new RelocElement();
        initializeRelocElement(stream, elem, refSectionID, aOutReader);
 
        relocSection->addElement(elem);
    }
}

References __func__, TPEF::Section::addElement(), assert, TPEF::AOutReader::header(), initializeRelocElement(), TPEF::Section::isCodeSection(), TPEF::AOutSectionReader::parent(), TPEF::BinaryStream::readPosition(), TPEF::RelocSection::referencedSection(), TPEF::AOutReader::Header::sectionSizeDataReloc(), TPEF::AOutReader::Header::sectionSizeTextReloc(), TPEF::Section::ST_DATA, TPEF::AOutReader::ST_DATA, TPEF::AOutReader::ST_TEXT, and TPEF::Section::type().

Here is the call graph for this function:

type()

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

protectedvirtual

Returns the type of section that reader can read.

Returns

The type of section that reader can read.

Implements TPEF::SectionReader.

Definition at line 85 of file AOutRelocationSectionReader.cc.

                                        {
    return Section::ST_RELOC;
}

References TPEF::Section::ST_RELOC.

Member Data Documentation

proto_

AOutRelocationSectionReader TPEF::AOutRelocationSectionReader::proto_

staticprivate

Class-wide (unique) prototype instance of AOutRelocationSectionReader registered into SectionReader.

Definition at line 91 of file AOutRelocationSectionReader.hh.

RELOCATION_TYPE_MASK

const Byte TPEF::AOutRelocationSectionReader::RELOCATION_TYPE_MASK = 0x1F

staticprivate

Mask for extracting relocation type.

Definition at line 94 of file AOutRelocationSectionReader.hh.

Referenced by initializeRelocElement().

---

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

• AOutRelocationSectionReader.hh
• AOutRelocationSectionReader.cc